Table of Contents
This document explains the samples that are bundled along with JAX-WS RI 2.3.0-SNAPSHOT.
The samples included with JAX-WS RI that is
distributed on GitHub documents how to use JAX-WS RI
in a non-Java EE 5 servlet container using a proprietary deployment
descriptor sun-jaxws.xml
and servlet
com.sun.xml.ws.transport.http.servlet.WSServlet
. This
means that you can these JAX-WS RI applications in any
servlet container that has been enabled with JAX-WS RI.
Applications that use the proprietary DD and servlet will run in a
JAX-WS RI enabled Java EE 5 servlet container, but they
will be non-portable. If you wish to use these JAX-WS RI
samples in a Java EE container in a Java EE portable manner you need to
modify them to use the standard Java EE 5 deployment descriptor; please
refer to the Java
EE 5 or Glassfish
documentation/samples.
All these samples are tested to run on Glassfish V2.1 build and on Apache Tomcat 5.x.
This section explains the directory structure of the
samples
directory in the bundle:
Table 29. List of Samples
Sample | Description |
---|---|
| jax-ws-ri-overview, this file |
| Demonstrates JAX-WS RI specific endpoint to achieve server side asynchrony. This sample requires Servlet 3.0 API supported container like Glassfish 3.0. |
| Demonstrates use of
|
| Demonstrates the simplified deployment of web services using JAX-WS RI deployment by not requiring the configuration of web.xml. |
| Starting from WSDL shows how to develop a WS-Addressing enabled endpoint using standardized Addressing Metadata support. |
| Starting from Java endpoint how to develop W3C WS-Addressing endpoint. |
| Starting from WSDL shows how to develop a WS-Addressing endpoint using WS-Addressing WSDL Binding. This sample uses non-standard wsdl extension, also see standards based fromwsdl-wsaddressing-policy sample. |
| Demonstrates how to build, deploy, and invoke a simple Web service starting from a Java service endpoint implementation using annotations. |
| Same as fromjava sample but with a simple logging handler on the client and server. |
| Demonstrates how to build, deploy, and invoke a simple Web service starting from a WSDL using external customizations. |
| Same as fromwsdl sample but demonstrates how to build, deploy, and invoke an HTTPS Web service and client from a WSDL. |
| Same as fromwsdl sample but with a simple logging handler on the client and server. |
| Demonstrates how to dynamically invoke web service endpoints. |
| Demonstrates how to build, deploy, and
invoke |
| Demonstrates how to build, deploy, and
invoke a server side asynchronous
|
| Same as fromjava but shows how to specify a different parameter name, operation name, targetNamespace, and other similar features. |
| Demonstrates how to generate async operations in a client SEI from a WSDL and invoke it from the client application. |
| Demonstrates efficient handler using
|
| Demonstrates how a client client application can customize a published WSDL using external binding file. |
| Demonstrates how to develop web service without using java annotations - metadata are being provided with xml descriptors. This allows to expose as a web service already deployed implementations. This sample uses fromjava (better to say from java binary) approach. |
| Demonstrates how to develop web service without using java annotations - metadata are being provided with xml descriptors. This allows to expose as a web service already deployed implementations. This sample uses fromwsdl approach. |
| Demonstrates how a client application and server endpoint can be generated from a WSDL with embedded binding declarations. |
| Demonstrates how to enable MTOM and swaRef. |
| Demonstrates how to transfer large attachments in streaming fashion using MTOM. |
| Same as mtom sample but shows how to specify SOAP 1.2 binding. |
| Same as fromjava sample but shows how to specify SOAP 1.2 binding. |
| Same as fromwsdl sample but shows how to specify SOAP 1.2 binding. |
| Same as fromjava sample but using JavaBeans as parameter and return types. Also the service can be built and deployed using Endpoint API. |
| Demonstrates how a MIME binding is
defined in the WSDL to send
|
| Demonstrates how to transfer large
attachment in streaming fashion using
|
| Demonstrates a how a WSDL and schema
URI's can be resolved using catalog mechanism using
wsimport ant tasks' catalog
attribute and also using ant's core type
|
| Shows the catalog capability on the client side; Catalog is used every time the implementation tries to access a resource identified by URI that is believed to contain either a WSDL document or any other document on which it depends . |
| Shows an example of a REST Web Service
implemented as a JAX-WS 2.0
|
| This sample shows the JAX-WS RI's stateful webservice support feature. |
| This sample demonstrates JAX-WS RI's validation feature that validates the incoming/outgoing messages are as per schema. |
| This sample demonstrates the
JAX-WS RI's featuer to expose the
same service class under |
| This sample demonstrates uploading a large file to the server. |
| This sample demonstrates type substitution and sending java types that are not directly referenced by the WSDL. |
| This sample demonstrates a REST based
webservices using |
Here is the list of prerequisites that needs to be met before any of the samples can be invoked:
Download Java SE 6 or later. Set JAVA_HOME
to the J2SE
installation directory.
Set JAXWS_HOME
to the JAX-WS
installation directory.
Follow the Installation Instructions from Release Notes.
Make sure that your container is configured for port 8080 as samples are hardcoded with this port info. Otherwise, you need to change samples to use the correct port by replacing '8080" with your port in all the files included in the sample.
Each sample has a readme.txt
in its
directory that details the instructions specific to the sample. Each
sample can be built, deployed and invoked using the
ANT_HOME/bin/ant
and build.xml
ant script in the root directory of the sample. Each ant script
supports the following set of targets:
Target | Description |
---|---|
| Builds and deploy the service endpoint
WAR on Glassfish v2 installation referenced by
|
| Builds and deploy the service endpoint
WAR on Tomcat installation referenced by
|
| Builds the client |
| Runs the client |
Some samples (e.g. fromjava,
supplychain) can be built, deployed using
javax.xml.ws.Endpoint
API. These samples support
extra targets:
Target | Description |
---|---|
| Builds and deploys the
|
server-j2se-stop | Stops the Endpoint API based
service endpoint (need to run from a different
window) |
It is essential for the service endpoint to be deployed on
Application Server before clients can be built because clients use the
WSDL exposed from the service endpoint deployed in the Application
Server. So please make sure that your Application Server is either
running before the server
target is invoked or run
it after the server
target is invoked. You will
have to wait a few minutes for the Application Server to deploy the
service endpoint correctly before building the client.
We appreciate your feedback, please send it to https://javaee.groups.io/g/metro.