<?xml version="1.0" encoding="utf-8"?>
<!--Arbortext, Inc., 1988-2005, v.4002-->
<!DOCTYPE reference PUBLIC "-//OASIS//DTD DITA Reference//EN"
 "reference.dtd">
<reference id="rwspref" xml:lang="en-us">
<title>Web services preferences</title>
<shortdesc>Before you begin developing Web services or clients, you can optimize
the workbench for Web services development by setting a variety of preferences.</shortdesc>
<prolog><metadata>
<keywords><indexterm>preferences<indexterm>Web services</indexterm></indexterm>
<indexterm>Web services<indexterm>preferences</indexterm></indexterm>
</keywords>
</metadata></prolog>
<refbody>
<section><p id="setprefmain">To set any of the Web services preferences, follow
these steps:<ol>
<li>Click  <uicontrol>Window > Preferences</uicontrol> to open the Preferences
notebook.</li>
<li>Expand  <uicontrol>Web services</uicontrol> or <uicontrol>Web and XML</uicontrol>,
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  <uicontrol>OK</uicontrol> 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  <uicontrol>F1</uicontrol>.</p><p>Web services tools enable you
to define the following preferences:</p><dl><dlentry id="axisemitterpref">
<dt>Axis Emitter</dt>
<dd>This page allows you to set the following preferences used when creating
or consuming Axis Web services.</dd>
<dd><b>WSDL2Java</b><ul>
<li>Generate code for all elements: By default, WSDL2Java only generates code
for those elements in the WSDL file that are referenced. For additional information
regarding how referencing works refer to the Axis reference guide: <xref href="http://ws.apache.org/axis/java/reference.html"
scope="external"></xref></li>
<li>Emits separate Helper classes for metadata: If you select this option
WSDL2Java will create a separate helper class that contains the metadata rather
than including it in the skeleton.</li>
<li>Prefers building beans to straight arrays for wrapped XML array types:
The default behavior is to map this XML construct: <codeblock>&lt;element name="array">
 &lt;complexType>
  &lt;sequence>
   &lt;element name="item" type="xs:string"/>
  &lt;/sequence>
 &lt;/complexType>
&lt;/element></codeblock>to a Java String array (String[]). If you would rather
a specific JavaBean class (ArrayOfString) be generated for these types of
schemas, select this option. </li>
<li>Add scope to deploy.wsdd: This indicates how to deploy the server implementation.
Application uses one instance of the implementation class for all requests.
Request creates a new instance of the implementation class for each request.
Session creates a new instance of the implementation class for each session.</li>
<li>Timeout in seconds: The default is 45. Use -1 to disable the timeout.</li>
</ul></dd>
<dd><b>Java2WSDL</b><ul>
<li>Look for allowed methods in inherited class: If this option is specified,
the Java2WSDL parser will look into extended classes to determine the list
of methods to export into the WSDL file. </li>
<li>Analyze the service class for compliance to JAX-RPC before generating
code: If selected, the tools will examine the Java service class and its value
types to determine if it satisfies important requirements of the JAX-RPC specification.</li>
</ul></dd>
</dlentry><dlentry id="popupdialogselect">
<dt>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>
</dlentry><dlentry id="wsicompliance">
<dt>Profile Compliance and Validation</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: <xref href="http://www.ws-i.org/"
scope="external"></xref></dd>
<dd>For validation preferences, you can choose whether or not WSDL files consumed
by the Web services wizards are validated, and whether or not the WSDL validation
must complete before the wizard will move to the next step.</dd>
</dlentry><dlentry id="projtopology">
<dt>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>
</dlentry><dlentry id="resourcemanagement">
<dt>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.<ul>
<li>Overwrite files without warning: selecting this will allow the wizards
to overwrite any existing files in the workspace without prompting. If it
is not selected you will be prompted each time a file needs to be overwritten.</li>
<li>Create folders when necessary: selecting this enables the wizards to create
any required folders.</li>
<li>Check out files without warning: select to check out files without receiving
a warning message asking for confirmation.</li>
<li>Merge generated skeleton file: this check box is disabled by default.
 If this check box is enabled, when a skeleton file of the same name already
exists in the workspace, the newly generated skeleton file will merge with
the existing skeleton file.  Enable this to preserve code that you have already
modified in the existing skeleton files.<p>Note that when this preference
is enabled, if you change the return type of an interface, the resulting skeleton
file will have a method returning the type as defined in the new interface
but would have a method body from the original skeleton file (which would
be returning a different type).  This will result in an compilation error
that the you will have to correct manually.</p></li>
</ul></dd>
</dlentry><dlentry id="scenariodefaults">
<dt>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 and client you want to be selected by default.</li>
<li>which phases of the Web service lifecycle you want to complete in 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 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>
</dlentry><dlentry id="serverandruntime">
<dt>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>
</dlentry><dlentry id="testfacilitydefaults">
<dt>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>
</dlentry><dlentry id="wsdlfiles">
<dt>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>
</dlentry></dl></section>
</refbody>
<related-links>
<linklist><title>Related Concepts</title>
<link href="../concepts/cwsinwsa.dita"></link>
</linklist>
<linklist><title>Related Tasks</title>
<link href="../tasks/toverws.dita" scope="peer"><linktext> Developing Web
services</linktext></link>
</linklist>
</related-links>
</reference>
