<?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="reference" name="DC.Type" />
<meta name="DC.Title" content="Web services preferences" />
<meta scheme="URI" name="DC.Relation" content="../concepts/cws.html" />
<meta scheme="URI" name="DC.Relation" content="../concepts/cwsinwsa.html" />
<meta scheme="URI" name="DC.Relation" content="../tasks/toverws.html" />
<meta content="XHTML" name="DC.Format" />
<meta content="rwspref" 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 preferences</title>
</head>
<body id="rwspref"><a name="rwspref"><!-- --></a>


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

<div>
<div class="section"><div class="p" id="rwspref__setprefmain"><a name="rwspref__setprefmain"><!-- --></a>To set any of the Web services preferences, follow
these steps:<ol>
<li>Click  <span class="uicontrol">Window &gt; Preferences</span> to open the Preferences
notebook.</li>

<li>Expand  <span class="uicontrol">Web services</span>, and click the preference
category that you want to set</li>

<li>Select the check boxes that you want to set as the default when creating
your Web service.</li>

<li>Click  <span class="uicontrol">OK</span> to apply the changes and close the Preferences
notebook.</li>

</ol>
If you require more information on any of the options, select the option
and press  <span class="uicontrol">F1</span>.</div>
<p>Web services tools enable you
to define the following preferences:</p>
<dl>
<dt class="dlterm"><a name="rwspref__popupdialogselect"><!-- --></a>Popup Dialog Selection</dt>

<dd>The Dialogs preferences enable you to determine which dialog boxes that
you want to see when running popup actions. If you have disabled any of the
dialogs by selecting "Do not show this dialog again" on the first page of
a Web services wizard, you can undo your change by clearing the check box
beside the dialog that you have chosen to hide.</dd>


<dt class="dlterm"><a name="rwspref__projtopology"><!-- --></a>Project Topology</dt>

<dd>The Project Topology preferences allow you to:<ul>
<li>Select the default client project type that the Web services wizards will
create when generating a Web service client. You can also set the order in
which the client project types will be listed in the wizard. Note that this
selection is simply a default and an alternate project type can be selected
in the wizard.</li>

<li>Select whether you want to generate the Web service and the Web service
client in the same EAR project or different EAR projects. Generating the service
and client into different EAR projects can reduce the chance of conflicts
that occur when both exist in a single EAR project, but uses more system resources.</li>

</ul>
</dd>


<dt class="dlterm"><a name="rwspref__resourcemanagement"><!-- --></a>Resource Management</dt>

<dd>The Resource Management preferences enable you to determine the file and
folder creation and overwriting defaults that you want to use when creating
your Web service.</dd>


<dt class="dlterm"><a name="rwspref__scenariodefaults"><!-- --></a>Scenario Defaults</dt>

<dd>The Scenario Defaults preferences enable you to set the following scenario
defaults that you want to use when creating your Web service:<ul>
<li>which type of Web service you want to be selected by default.</li>

<li>whether or not you want the Web service started by the wizard.</li>

<li>if you want the Web Services Explorer to launch by default so that you
can publish your Web service to a UDDI registry.</li>

<li>if you want to generate a proxy and the default type of proxy generated.</li>

<li>if you want the Web Services Explorer to launch by default so that you
can test the Web service.</li>

<li>if you want the Web service SOAP traffic routed through a TCP/IP monitor
so that you can monitor the SOAP packets and optionally test them for WS-I
compliance.</li>

</ul>
Note that all these defaults can be overridden in the wizard.</dd>


<dt class="dlterm"><a name="rwspref__serverandruntime"><!-- --></a>Server and Runtime</dt>

<dd>Select the server, Web service run-time environment, and J2EE version
that you want selected by default in the Web services wizard. Note that all
these defaults can be overridden in the wizard.</dd>


<dt class="dlterm"><a name="rwspref__testfacilitydefaults"><!-- --></a>Test Facility Defaults</dt>

<dd>can select whether to have the wizard automatically launch a test facility,
and you can select your preferred type of test facility</dd>


<dt class="dlterm"><a name="rwspref__wsdlfiles"><!-- --></a>WSDL files</dt>

<dd>When creating a WSDL file in the WSDL editor, you can set the default
target namespace. If you do not select to change the default, your WSDL file
will have http://tempuri.org as its target namespace.</dd>


<dt class="dlterm"><a name="rwspref__wsicompliance"><!-- --></a>WS-I Compliance</dt>

<dd>The WS-I Compliance preferences allow you to select your level of compliance
with the WS-I Simple SOAP Binding Profile (SSBP) and WS-I Attachement Profile
(AP). Note: if you change the level of WS-I compliance while WS-I incompliances
are listed in the Task view, the Task view will not be automatically updated.
The workspace must be revalidated before the warnings will be removed from
the Task view. For more information on WS-I, refer to: </dd>

</dl>
</div>

</div>

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

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

<div><a href="../concepts/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>