Professional Documents
Culture Documents
Hospital Scenario: B2B Database Query Using Web Services, JSP, Servlets, and XML Tools
Hospital Scenario: B2B Database Query Using Web Services, JSP, Servlets, and XML Tools
WebSphere
Studio
Hospital
scenario:
B2B
database
query
using
Web
services,
JSP,
servlets,
and
XML
tools
Fifth
Edition
(December
2003)
This
edition
applies
to
Version
5.1.1
of
IBM
WebSphere
Studio
and
to
all
subsequent
releases
and
modifications
until
otherwise
indicated
in
new
editions.
Ensure
that
you
are
using
the
correct
edition
for
the
level
of
the
product.
Copyright
International
Business
Machines
Corporation
2000,
2003.
All
rights
reserved.
US
Government
Users
Restricted
Rights
Use,
duplication
or
disclosure
restricted
by
GSA
ADP
Schedule
Contract
with
IBM
Corp.
Note!
Before
using
this
information
and
the
product
it
supports,
be
sure
to
read
the
general
information
under
Notices.
Contents
Chapter
1.
Overview
.
.
.
.
.
.
.
.
. 1
Implementation
Details
.
.
.
.
.
.
.
.
.
.
. 2
Retrieving
patient
information
.
.
.
.
.
.
. 3
Submitting
the
insurance
claim
.
.
.
.
.
.
. 3
Processing
the
claim
.
.
.
.
.
.
.
.
.
.
. 4
Displaying
the
claim
response
.
.
.
.
.
.
. 4
About
Web
service
standards
.
.
.
.
.
.
.
.
. 4
Accessing
Web
services
.
.
.
.
.
.
.
.
.
. 5
About
DADX
.
.
.
.
.
.
.
.
.
.
.
.
.
. 6
Accessing
DB2
using
DADX
operations
.
.
.
. 6
Next
step
.
.
.
.
.
.
.
.
.
.
.
.
.
.
. 6
Chapter
2.
Preparing
for
the
sample
application
.
.
.
.
.
.
.
.
.
.
.
.
. 7
System
prerequisites
.
.
.
.
.
.
.
.
.
.
.
. 7
Enabling
JDBC
2.0
on
DB2
(Windows
only)
.
.
.
. 7
Creating
the
hospital
and
insurance
databases
.
.
. 8
Next
step
.
.
.
.
.
.
.
.
.
.
.
.
.
.
. 9
Chapter
3.
Developing
the
code
for
the
patient
Web
service
.
.
.
.
.
.
.
.
. 11
Creating
the
Web
project
.
.
.
.
.
.
.
.
.
. 11
Creating
the
DADX
group
.
.
.
.
.
.
.
.
. 11
Generating
the
DADX
file
.
.
.
.
.
.
.
.
. 12
Importing
the
DADX
file
.
.
.
.
.
.
.
.
. 12
Creating
the
SQL
query
.
.
.
.
.
.
.
.
. 13
Creating
the
DADX
file
.
.
.
.
.
.
.
.
. 16
Creating
the
patient
Web
service
.
.
.
.
.
.
. 16
Testing
the
patient
Web
service
.
.
.
.
.
.
. 18
Next
step
.
.
.
.
.
.
.
.
.
.
.
.
.
.
. 18
Chapter
4.
Developing
the
code
for
the
insurance
Web
service
.
.
.
.
.
.
.
. 19
Creating
the
Web
project
.
.
.
.
.
.
.
.
.
. 19
Importing
the
JAR
file
.
.
.
.
.
.
.
.
.
.
. 19
Generating
the
source
code
for
the
database
query
20
Importing
the
source
files
.
.
.
.
.
.
.
. 21
Importing
the
DTD
file
and
insurance
bean
.
.
. 21
Creating
the
SQL
query
.
.
.
.
.
.
.
.
. 22
Generating
the
XSL
file
.
.
.
.
.
.
.
.
. 26
Creating
the
insurance
Web
service
.
.
.
.
.
. 28
Testing
the
insurance
Web
service
.
.
.
.
.
. 29
Next
step
.
.
.
.
.
.
.
.
.
.
.
.
.
.
. 30
Chapter
5.
Creating
and
deploying
the
hospital
application
.
.
.
.
.
.
.
.
. 31
Creating
the
project
.
.
.
.
.
.
.
.
.
.
.
. 31
Importing
the
XSD
JAR
files
.
.
.
.
.
.
.
.
. 31
Importing
the
client
code
.
.
.
.
.
.
.
.
.
. 32
Copy
the
proxies
from
the
PatientProjClient
and
InsuranceProjClient
projects.
.
.
.
.
.
.
.
.
. 33
Next
step
.
.
.
.
.
.
.
.
.
.
.
.
.
.
. 33
Chapter
6.
Running
the
hospital
sample
application
and
testing
the
Web
service
35
Submitting
the
claim
.
.
.
.
.
.
.
.
.
.
. 35
Viewing
the
claim
response
.
.
.
.
.
.
.
.
. 36
Summary
.
.
.
.
.
.
.
.
.
.
.
.
.
.
. 37
Notices
.
.
.
.
.
.
.
.
.
.
.
.
.
. 39
Programming
interface
information
.
.
.
.
.
. 41
Trademarks
and
service
marks
.
.
.
.
.
.
.
. 41
Copyright
IBM
Corp.
2000,
2003
iii
iv
Chapter
1.
Overview
In
the
business
world,
data
frequently
needs
to
be
exchanged
between
different
organizations,
such
as
a
hospital
and
an
insurance
company.
Different
organizations
collect,
store,
and
process
information
differently,
making
data
exchange
difficult
and
time-consuming.
The
solution
is
to
store
data
in
a
common
format,
and
to
develop
an
application
that
integrates
and
automates
the
exchange
of
data
between
different
businesses
across
the
Internet.
You
will
use
WebSphere
Studio
to
develop
this
type
of
application.
In
this
application,
data
exchange
is
accomplished
using
XML,
and
business
processes
are
integrated
using
Web
services
and
Simple
Object
Access
Protocol
(SOAP).
The
Hospital
scenario
demonstrates
how
multiple
features
of
WebSphere
Studio
are
combined
in
an
end-to-end
development
scenario
to
build
an
e-business
application.
To
develop
this
application,
you
will
use
XML
tools
and
Web
service
tools.
The
sample
application
that
you
will
develop
consists
of
a
hospital
application,
a
patient
Web
service,
and
an
insurance
Web
service.
Each
of
these
applications
is
distributed
over
four
logical
machines,
as
shown
in
the
following
diagram:
The
client
is
a
hospital
employee
who
processes
patient
information
and
submits
insurance
claims
on
behalf
of
the
patient.
This
employee
enters
the
patient
information
and
makes
a
query
to
the
hospital
server.
The
server
uses
a
Web
service
to
call
the
patient
and
insurance
servers
to
obtain
the
information
requested.
The
arrows
represent
a
request-response
transaction.
The
client
machine
accesses
the
hospital
application
through
a
Web
browser.
The
Web
browser
prompts
the
client
to
enter
information
required
for
a
query.
The
client
submits
the
request
and
the
clients
browser
displays
the
response
from
the
hospital
application.
In
this
scenario,
the
cost
of
a
patients
hospital
visit
is
paid
for
by
the
patients
insurance
company.
The
following
steps
explain
how
the
necessary
information
flows
through
the
scenario.
1.
To
receive
payment,
the
hospital
must
submit
a
claim
to
the
insurance
company.
To
begin
the
data
exchange,
a
hospital
employee
enters
an
account
number
for
the
patient
into
a
form
displayed
in
a
Web
browser
(HospitalInput.jsp)
on
the
client.
2.
The
hospital
application
retrieves
information
about
the
patient
from
a
Document
Access
Definition
Extender
(DADX)
Web
service,
and
invokes
a
Copyright
IBM
Corp.
2000,
2003
1
JavaServer
Pages
(JSP)
page
to
display
the
results
in
the
Web
browser
(HospitalResults.jsp).
DADX
is
explained
in
more
detail
later
in
this
chapter.
3.
The
employee
adds
additional
information
about
the
patient
to
the
page
and
returns
the
information
to
the
hospital
application.
4.
The
hospital
application
generates
an
insurance
claim
from
the
patient
information,
and
sends
it
across
the
Internet
to
the
insurance
Web
service
for
processing.
5.
The
insurance
Web
service
processes
the
claim,
and
returns
a
claim
response
to
the
hospital
application
which
invokes
another
JSP
to
display
the
result
(ClaimResponse.jsp)
on
the
client.
The
hospital
application
is
implemented
with
Java
servlets,
JSP,
and
HTML.
The
main
function
of
the
hospital
application
is
to
provide
a
user
interface
to
the
client.
The
patient
Web
service
responds
to
requests
for
patient
information
from
the
hospital
server.
In
the
sample
application,
the
patient
Web
service
implements
a
DADX
Web
service
to
query
DB2
for
patient
information.
The
patient
Web
service
then
returns
the
results
to
the
hospital
application
as
a
SOAP
encoded
XML
document.
The
insurance
Web
service
processes
the
insurance
claim
submitted
by
the
hospital
application
through
a
Java
bean
Web
service.
The
insurance
bean
performs
a
DB2
SQL
query
and
returns
an
XML
stream.
The
XML
stream
is
then
transformed
using
standard
XSL
technology
into
the
XML
document
that
is
returned
to
the
hospital
application.
From
the
hospital
employees
perspective,
this
is
a
simple,
seamless
transaction
that
takes
place
in
a
Web
browser
on
the
client.
However,
this
transaction
is
more
complex.
Data
is
collected
from
different
sources,
transformed
into
a
common
format,
and
exchanged
across
the
Internet
between
different
organizations.
The
following
sections
provide
more
details
about
the
technologies
that
underlie
the
sample
application,
how
the
sample
application
implements
those
technologies,
and
what
tools
you
will
use
to
develop
the
sample
application.
If
you
do
not
wish
to
complete
the
scenario
but
would
like
to
run
the
application,
follow
the
steps
in
the
Preparing
for
the
sample
application
section,
then
import
the
scenario
into
your
workbench
by
selecting
File
>
New
>
Other
>
Example
Project
>
Enterprise
Applications
>
Hospital.
Run
the
scenario
by
following
the
instructions
provided
when
the
scenario
is
installed.
Implementation
Details
To
exchange
data
between
the
hospital
Web
application,
the
patient
Web
service,
and
the
insurance
Web
service,
the
sample
application
performs
four
major
tasks:
v
Retrieves
patient
information
v
Submits
the
insurance
claim
v
Processes
the
claim
v
Displays
the
claim
response
These
tasks
are
divided
between
the
hospital
application,
the
patient
Web
service,
and
the
insurance
Web
service
as
described
in
the
following
sections.
2
Retrieving
patient
information
The
hospital
application
consists
of
several
components,
shown
in
the
following
diagram,
that
are
used
to
retrieve
patient
information
and
display
it
to
the
hospital
employee
on
the
client.
At
run
time,
the
hospital
servlet
responds
to
the
request
to
retrieve
patient
information.
The
hospital
servlet
communicates
with
the
DADX
run-time
through
the
patient
proxy.
The
patient
proxy
sends
information
such
as
the
name
of
the
DADX
group,
the
name
of
the
DADX
file,
and
any
parameters
required
by
the
DADX
file
to
the
DADX
run-time.
In
this
scenario,
the
patient
proxy
sends
the
group
name
patientGroup,
the
file
name
patient.dadx,
and
the
patient
account
number
to
the
run-time
environment.
The
DADX
run-time
locates
the
patient
group
and
DADX
file
and
queries
the
database.
The
run-time
returns
the
result
to
the
patient
proxy
as
an
XML
document
using
the
SOAP
protocol.
The
hospital
application
then
displays
the
result
in
a
Web
browser
on
the
client.
Submitting
the
insurance
claim
The
hospital
application
consists
of
an
additional
component,
shown
in
the
following
diagram,
that
is
used
to
submit
the
insurance
claim
to
the
insurance
Web
service.
Chapter
1.
Overview
3
The
insurance
claim
servlet
makes
a
claim
request
through
the
insurance
proxy
to
the
InsuranceServiceBean
bean.
The
proxy
calls
the
bean
with
the
input
parameters
to
make
the
claim.
In
this
scenario,
the
patients
Social
Security
Number
(SSN)
is
the
input
parameter.
The
SQL
to
XML
run-time
code
reads
the
template
.xst
file,
substitutes
the
SSN
parameter,
and
then
performs
the
query.
The
query
returns
an
XML
stream.
Processing
the
claim
The
insurance
Web
service
consists
of
several
components,
shown
in
the
diagram
above,
that
are
used
to
process
the
claim.
You
will
create
the
query
template
file
using
the
SQL
query
builder,
and
the
response.xsl
file
using
the
XML
mapping
editor.
In
order
to
filter
unwanted
data
from
the
query
response,
and
to
generate
a
result
that
conforms
to
the
hospitals
required
format
for
a
return,
an
XSL
transformation
style
sheet
(response.xsl)
is
applied.
The
resulting
XML
document
is
returned
to
the
insurance
claim
servlet.
Displaying
the
claim
response
The
hospital
application
also
contains
components,
shown
in
the
following
diagram,
that
are
used
to
display
the
claim
response
to
the
hospital
employee.
The
following
section
describes
how
these
technologies
are
implemented
in
the
sample
application.
About
Web
service
standards
The
sample
application
that
you
will
develop
is
a
distributed
application
in
which
the
patient
information
retrieval
and
claim
processing
functions
are
implemented
in
Web
services
located
on
remote
workstations.
These
functions
are
accessed
by
a
hospital
application
through
a
method
call.
The
call
is
sent
over
the
Internet
using
SOAP.
A
Web
service
is
a
set
of
related
application
functions
that
can
be
programmatically
invoked
over
the
Internet.
Web
Services
Description
Language
(WSDL)
documents
will
be
indexed
in
a
searchable
Universal
Description,
Discovery,
and
Integration
(UDDI)
Business
Registry.
The
UDDI
specification
defines
open,
platform-independent
standards
that
enable
businesses
to
share
information
in
a
global
registry.
The
UDDI
Business
Registry
is
poised
to
become
a
vast
library
of
functions
available
to
all
developers.
Using
the
Web
services
in
the
Business
Registry,
applications
can
use
data
and
resources
that
are
available
on
the
Web,
just
as
they
now
use
resources
that
are
available
to
them
locally.
4
WSDL
is
an
XML-based
open
specification
that
describes
the
interfaces
to
and
instances
of
Web
services
on
the
network.
It
is
extensible,
so
endpoints
can
be
described
regardless
of
the
message
formats
or
network
protocols
that
are
used
to
communicate.
For
more
information
on
WSDL,
refer
to
(www.w3.org/TR/wsdl)
SOAP
is
a
protocol
that
defines
a
standard
way
for
distributed
applications
to
communicate
over
the
Internet.
SOAP
enables
programmers
to
invoke
remote
services
in
a
platform-neutral
manner
in
much
the
same
way
that
Web
browsers
can
access
Web
servers
regardless
of
the
platform
on
which
the
servers
run.
The
following
diagram
illustrates
the
relationships
between
SOAP,
UDDI,
and
WSDL.
Together,
Web
services
and
SOAP
enable
businesses
to
make
their
services
available
to
many
potential
clients
using
a
standard
connection
protocol.
This
makes
it
possible
for
related
businesses,
such
as
insurance
companies
and
health
care
providers,
to
integrate
their
business
processes
over
the
Internet,
making
transactions
easier
and
more
efficient.
For
more
information
about
SOAP,
refer
to
the
(Apache
SOAP)
site.
For
a
tutorial
that
covers
only
Web
services,
refer
to
the
Getting
Started
document
for
WebSphere
Studio.
For
more
information
on
Web
services,
refer
to
the
online
help.
Accessing
Web
services
To
access
a
remote
method
in
a
Web
service,
a
Web
service
proxy
is
created.
The
proxy
provides
a
Java
interface
to
the
Web
service.
Using
the
proxy,
the
application
calls
a
remote
method
on
the
Web
service
as
if
the
method
were
a
local
one.
Once
the
application
makes
the
remote
call,
the
proxy
handles
all
of
the
communication
details
between
the
application
and
the
Web
service
using
SOAP.
The
proxy
sends
the
remote
call
to
the
Web
service
as
a
SOAP
message.
SOAP
messages
are
essentially
XML
documents
with
another
layer
of
abstraction
for
the
protocol
requirements.
Encoding
data
in
XML
makes
it
a
platform-neutral,
plain-text
object
that
can
be
sent
using
HTTP.
After
the
Web
service
processes
the
call,
it
returns
a
SOAP
response
to
the
calling
application
with
the
result.
Chapter
1.
Overview
5
About
DADX
The
DAD
Extension
(DADX)
is
an
extension
of
the
Document
Access
Definition
(DAD)
file
in
the
DB2
XML
Extender
and
includes
standard
SQL
functionality
that
does
not
use
the
XML
Extender.
A
DADX
document
enables
the
creation
of
Web
services
that
store
and
retrieve
XML
documents.
A
DADX
document
specifies
how
to
create
a
Web
service
using
a
set
of
operations
that
are
defined
by
SQL
statements
and,
optionally,
DAD
files.
Accessing
DB2
using
DADX
operations
Web
service
access
to
DB2
stored
procedures
and
data
is
provided
through
tools
and
run-time
software.
Three
kinds
of
Web
service
operations
are
supported:
v
XML
document-based
(query
and
store
XML)
v
SQL-based
(query,
insert,
delete,
and
update)
v
DB2
stored
procedure
invocations
Both
XML-based
and
SQL-based
operations
are
controlled
by
a
DADX
file.
The
DB2
XML
Extender
provides
the
support
for
the
XML-based
operations
that
store
or
retrieve
XML
documents
from
a
DB2
database.
An
XML
document
can
be
either
stored
in
an
XML
column,
along
with
its
tags,
or
decomposed
into
a
collection
of
rows
in
tables
using
traditional
relational
data
types.
Similarly,
an
XML
document
can
be
retrieved
from
an
XML
column
or
can
be
generated
from
a
collection
of
rows
in
tables.
A
user-specified
file
provides
control
over
the
mapping
of
XML
document
elements
to
DB2
database
columns
for
storage
and
retrieval,
called
the
Document
Access
Definition
(DAD)
file.
The
XML
Extender
offers
a
set
of
stored
procedures
to
decompose
an
XML
document
into
existing
table
structures
or
to
generate
an
XML
document
from
existing
relational
data.
All
of
these
features
of
the
DB2
XML
Extender
can
be
invoked
through
Web
services.
For
more
information
about
the
DB2
XML
Extender
see
(
www.ibm.com/software/data/db2/extenders/xmlext/library.html)
and
select
the
latest
documentation
for
your
platform.
Under
the
Administration
section,
open
the
XML
Extender
Administration
and
Programming
guide.
The
following
section
describes
the
tools
you
will
use
to
develop
the
sample
application.
Next
step
Before
you
can
build
the
sample
application,
you
need
to
prepare
your
development
environment.
The
next
section
describes
the
preparations
you
need
to
make.
6
Chapter
2.
Preparing
for
the
sample
application
Before
you
can
develop
the
sample
application,
you
need
to
perform
the
following
steps:
v
Install
the
prerequisite
software
on
your
workstation
v
Create
the
hospital
and
insurance
databases
The
following
sections
provide
details
about
each
of
these
tasks.
System
prerequisites
You
need
the
following
software
installed
on
your
workstation:
v
DB2
Universal
Database
(UDB)
for
Windows
Version
7.2
or
higher
installed
locally.
DB2
is
included
with
most
configurations
of
the
WebSphere
Studio
product
family.
If
DB2
was
not
included
in
your
WebSphere
Studio
package,
you
can
download
it
from
www.ibm.com/software/data/db2.
The
scenario
will
not
work
if
fixpack
4
is
installed
on
version
7.2.
v
DB2
Universal
Database
(UDB)
for
Linux
Version
7.2
or
higher
installed
locally
to
the
default
location.
v
Netscape
version
6.0
or
higher
or
Mozilla
version
0.7
or
higher
For
more
information
on
DB2,
refer
to
www.ibm.com/cgi-
bin/db2www/data/db2/udb/winos2unix/support/v7pubs.d2w/en_main
Enabling
JDBC
2.0
on
DB2
(Windows
only)
Note:
The
following
instructions
are
applicable
for
DB2
Universal
Database
Version
7.2
and
are
not
intended
for
use
with
DB2
Universal
Database
Version
8.
JDBC
2.0
allows
Java
applications
to
access
relational
and
non-relational
database
management
systems.
The
following
section
only
applies
to
Windows.
To
ensure
that
JDBC
2.0
is
enabled
on
DB2:
1.
Stop
all
DB2
processes.
2.
From
a
command
prompt
run
the
usejdbc2
batch
file
in
DB2_INSTALL_PATH\SQLLIB\java12
where
DB2_INSTALL_PATH
is
the
path
where
you
installed
DB2.
3.
From
the
Services
window,
restart
the
following
services:
v
DB2
JDBC
Applet
Server
v
DB2
JDBC
Applet
Server
-
Control
Center
v
IBM
WS
AdminServer
Copyright
IBM
Corp.
2000,
2003
7
Important:
If
you
are
denied
access
when
running
the
usejdbc2
batch
file,
you
have
not
stopped
all
of
the
DB2
processes.
Creating
the
hospital
and
insurance
databases
Before
you
can
develop
the
sample
application,
you
need
to
create
the
hospital
and
insurance
databases.
The
sample
application
retrieves
patient
information
from
the
patient
database
and
policy
holder
data
from
the
insurance
database.
To
create
these
databases,
you
will
use
setup
files
that
are
supplied.
The
files
create
the
following
databases
and
tables:
Database
Tables
HOSPITAL
HEALTHCARERECORD
INSURE
CLIENTINFO
POLICYINFO
To
create
the
databases,
do
the
following:
1.
Switch
to
a
Command
Prompt
window.
2.
Go
to
the
following
directory:
WS_Installdir\wstools\eclipse\plugins\com.ibm.etools.webservice_version\
samples\hospital\create_databases
where
WS_Installdir
is
the
drive
and
directory
where
WebSphere
Studio
is
installed
and
version
is
the
version
number
of
the
plug-in.
3.
Type
the
following
command:
db2cmd.
This
command
opens
the
DB2
Command
Line
Processor
(CLP)
window.
4.
In
the
DB2
CLP
window,
invoke
the
hospital
batch
file
by
typing
the
following
command:
hospital.
The
batch
file
uses
the
hospital.txt
file
to
create
the
hospital
database.
You
should
see
messages
indicating
that
the
various
DB2
commands
in
the
batch
file
completed
successfully.
5.
In
the
DB2
CLP
window,
invoke
the
insurance
batch
file
by
typing
the
following
command:
insure.
The
batch
file
uses
the
client.txt
and
policy.txt
files
to
create
the
insurance
database.
You
should
see
messages
saying
that
the
various
DB2
commands
in
the
batch
file
completed
successfully.
In
addition
to
viewing
the
messages
displayed
by
the
batch
files,
you
can
use
the
DB2
Control
Center
to
check
that
the
databases
created
successfully.
1.
Ensure
that
you
are
logged
on
as
user
db2inst1.
2.
Open
a
terminal
window.
3.
Go
to
the
following
directory:
WS_Installdir/wstools/eclipse/plugins/com.ibm.etools.webservice_version/
samples/hospital/create_databases
where
WS_Installdir
is
the
drive
and
directory
where
WebSphere
Studio
is
installed
and
version
is
the
version
number
of
the
plug-in.
4.
Invoke
the
hospital
shell
script
by
typing
the
following
command:
./hospital.sh.
You
should
see
messages
indicating
that
the
various
DB2
commands
in
the
shell
script
completed
successfully.
8
5.
Invoke
the
insurance
shell
script
by
typing
the
following
command:
./insure.sh.
You
should
see
messages
saying
that
the
various
DB2
commands
in
the
shell
file
completed
successfully.
In
this
project,
an
SQL
script
file
is
used
to
create
the
required
tables
on
the
iSeries
.
The
script
file
is
located
in
WS_Installdir/wstools/eclipse/plugins/com.ibm.etools.webservice_version/
samples/hospital/create_databases
in
the
navigator
view
of
the
project.
To
create
the
tables
and
run
the
example,
the
driver
file
that
accesses
the
iSeries
database
must
be
locally
available
on
your
workstation.
The
driver
file
name
is
jt400.jar
and
is
located
in
the
IFS
of
the
iSeries
in
/QIBM/ProdData/HTTP/Public/lib/jt400.jar.
You
can
either
map
a
network
drive
to
this
location
or
copy
the
jt400.jar
file
to
a
hard
drive
on
your
workstation.
You
must
also
ensure
that
the
jt400.jar
file
is
referenced
in
the
Class
path
of
the
Server
Configuration
before
you
run
the
sample
applications.
To
create
the
tables
on
the
iSeries:
1.
Right-click
hospital-iseries.sql.
2.
Select
Run
on
Database
Server...
from
the
popup
menu.
3.
Click
Next
in
the
Run
Script
window.
4.
Select
Commit
changes
only
upon
success
and
click
Next
on
the
Options
window.
5.
Enter
the
following
values
in
the
Database
Connection
window
and
click
Finish:
v
Database:
example
v
user
ID:
Your
iSeries
user
ID
v
Password:
Your
iSeries
password
v
Database
vendor
type:
DB2
Universal
Database
for
iSeries,
V5R1
v
JDBC
driver:
AS/400
Toolbox
for
Java
JDBC
Driver
v
Host:
system_name/example
v
Class
location:
Specify
the
location
of
the
jt400.jar
file
referenced
earlier
v
Accept
the
defaults
for
all
other
fields.
6.
Verify
that
there
are
no
errors
in
the
Confirm
export
results
window
and
click
Commit
changes.
Next
step
Once
you
complete
the
preparation
tasks,
you
are
ready
to
develop
the
patient
application.
Chapter
2.
Preparing
for
the
sample
application
9
10
Chapter
3.
Developing
the
code
for
the
patient
Web
service
In
this
section,
you
will
use
the
XML
tools
to
generate
the
code
required
by
the
patient
application
by
doing
the
following:
v
Create
the
Web
project
that
will
contain
the
source
files
for
the
patient
application
v
Create
a
DADX
group
within
the
Web
project
v
Create
an
SQL
statement
that
will
query
the
hospital
database
for
patient
information
v
Create
a
DADX
file
from
the
SQL
statement
v
Create
the
patient
Web
service
The
patient
Web
service
responds
to
requests
for
patient
information
from
the
hospital
server.
The
patient
Web
service
implements
a
DADX
Web
service
to
query
DB2
for
patient
information.
The
patient
Web
service
then
returns
the
results
to
the
hospital
application
as
a
SOAP
encoded
XML
document.
Creating
the
Web
project
Before
you
can
develop
the
patient
Web
service,
you
need
to
create
a
Web
project
that
will
contain
the
code
for
the
patient
Web
service.
The
patient
Web
project
contains
the
patient
artifacts
such
as
the
DADX
group
and
the
DADX
file.
To
create
the
Web
project,
do
the
following:
1.
Switch
to
the
Web
perspective
(Window
>
Open
Perspective
>
Other
>
Web).
2.
From
the
workbench,
click
File
>
New
>
Dynamic
Web
Project.
3.
Type
PatientProj
in
the
Project
name
entry
field.
4.
Click
Finish
to
create
the
PatientProj
project.
The
PatientProj
and
DefaultEAR
projects
are
created.
The
Enterprise
Application
project
stores
the
Web
project
as
a
WAR
file
embedded
in
an
EAR
file
that
can
be
exported
to
a
server.
Continue
with
the
next
step
Creating
the
DADX
group.
Creating
the
DADX
group
The
DADX
group
contains
connection
and
other
information
that
is
shared
between
DADX
files.
To
create
the
DADX
group,
do
the
following:
1.
Switch
to
the
Web
perspective
(Window
>
Open
Perspective
>
Other
>
Web)
if
necessary.
2.
In
the
Project
Navigator
view,
select
PatientProj.
Copyright
IBM
Corp.
2000,
2003
11
3.
Click
File
>
New
>
Other
>
Web
Services
in
order
to
display
the
various
Web
service
wizards.
Select
the
Web
Service
DADX
Group
Configuration
wizard.
Click
Next.
4.
Right-click
PatientProj.
Select
Add
group.
In
the
DADX
group
name
text
field,
type
patientGroup.
Click
OK.
5.
Expand
PatientProj
and
right-click
patientGroup.
Select
Group
Properties.
Change
the
DB
URL
to
jdbc:db2:hospital.
Click
OK.
Enter
your
iSeries
user
ID
and
password.
The
DB
Driver
should
be
com.ibm.as400.access.AS400JDBCDriver
and
the
DB
URL
should
be
jdbc:as400://server_name/example,
where
server_name
is
the
name
of
your
iSeries
server.
6.
Click
Finish.
Your
DADX
group
is
generated
in
the
PatientProj\JavaSource\groups.patientGroup
folder.
If
you
expand
the
PatientProj,
Java
Resources,
and
groups.patientGroup
folders,
your
Project
Navigator
view
should
look
similar
to
the
diagram
below.
Generating
the
DADX
file
DAD
Extension
(DADX)
is
an
XML
document
format
that
specifies
how
to
create
a
Web
service
using
a
set
of
operations
that
are
defined
by
DAD
documents
and
SQL
statements.
You
can
import
the
DADX
file,
or
create
your
own
by
creating
an
SQL
query
and
generating
a
DADX
file
from
the
results
using
the
SQL
from
XML
wizard.
The
patient.dadx
file
contains
the
DB2
query
and
a
description
of
the
required
account
parameter.
Important:
You
can
either
import
this
DADX
file
or
you
can
create
it
using
the
SQL
builder
and
XML
from
SQL
creation
wizards.
v
To
import
the
DADX
file,
follow
the
directions
in
Importing
the
DADX
file,
then
skip
Creating
the
SQL
query,
and
Creating
the
DADX
file.
v
To
create
the
DADX
file,
skip
the
Importing
the
DADX
file
section
and
following
the
directions
in
Creating
the
SQL
query
and
Creating
the
DADX
file.
Importing
the
DADX
file
To
import
the
DADX
file,
do
the
following:
1.
In
the
Project
Navigator
view,
select
the
groups.patientGroup
group
in
the
Java
Resources
folder
of
your
PatientProj
project.
2.
Click
File
>
Import
to
open
the
Import
wizard.
3.
Click
File
system
from
the
Select
an
import
source
list,
then
click
Next.
12
4.
In
the
Directory
text
field,
specify
the
following
location
of
the
DADX
file.
Use
the
Browse
button
if
necessary:
WS_Installdir\wstools\eclipse\plugins\com.ibm.etools.webservice_version\
samples\hospital\PatientProj\JavaSource\groups\patientGroup
5.
Click
OK.
6.
Click
Select
All
and
select
Overwrite
existing
resources
without
warning.
7.
Click
Finish.
The
patient.dadx
file
is
imported
into
the
PatientProj.
Now
that
you
have
imported
the
DADX
file,
continue
the
scenario
with
Creating
the
patient
Web
service.
Creating
the
SQL
query
To
create
the
SQL
query
instead
of
importing
it,
you
need
to
do
the
following:
v
Define
the
database
connection
v
Define
the
SQL
statement
v
Test
the
query
v
Generate
the
template
file
The
following
sections
provide
details
about
each
of
these
tasks.
Defining
the
database
connection
Next,
you
need
to
define
the
connection
to
the
hospital
database
by
doing
the
following:
1.
Select
Window
>
Open
Perspective
>
Other
>
Data.
2.
Right-click
anywhere
in
the
DB
Servers
pane,
then
click
New
Connection.
The
New
Connection
wizard
opens.
3.
In
the
Connection
Name
entry
field,
type
Hospital_connection.
4.
In
the
Database
entry
field,
type
hospital.
In
the
Database
entry
field,
type
example.
5.
In
the
User
ID
and
Password
fields,
type
your
DB2
user
id
and
password.
In
the
User
ID
and
Password
fields,
type
your
iSeries
user
ID
and
password.
6.
In
the
Database
vendor
type
field,
ensure
that
the
correct
database
driver
is
selected.
7.
In
the
JDBC
driver
field,
ensure
that
the
correct
JDBC
driver
is
selected.
8.
In
the
Class
location
field,
ensure
that
the
path
to
your
to
your
JDBC
driver
class
(in
db2java.zip)
is
correct.
In
the
Class
location
field,
ensure
that
the
path
to
your
JDBC
driver
class
(jt400.jar)
is
correct.
9.
Click
Finish.
A
connection
to
the
hospital
database
is
defined.
Now
that
youve
defined
the
database
connection,
you
need
to
copy
the
connection
information
to
the
PatientProj
project,
by
doing
the
following:
Chapter
3.
Developing
the
code
for
the
patient
Web
service
13
1.
In
the
DB
Servers
pane,
expand
Hospital_connection
and
right-click
hopsital(jdbc:db2:hospital),
and
from
the
pop-up
menu
select
Import
to
Folder.
In
the
DB
Servers
pane,
expand
Hospital_connection
and
right-click
example(jdbc:as400://server_name),
and
from
the
pop-up
menu
select
Import
to
Folder.
2.
In
the
Import
to
Folder
dialog,
click
Browse
and
select
the
PatientProj
project.
3.
Click
OK,
then
click
Finish.
4.
Click
Yes
to
confirm
the
creation
of
the
databases
folder.
Defining
the
SQL
statement
The
SQL
statement
specifies
the
tables
and
fields
that
you
want
to
query
in
the
hospital
database,
and
the
conditions
that
will
govern
the
query.
To
define
the
SQL
statement,
you
first
give
the
statement
a
name
by
doing
the
following:
1.
Make
sure
you
are
in
the
Data
perspective
(Window
>
Open
Perspective
>
Other
>
Data).
2.
Click
the
Data
Definition
tab.
3.
Expand
the
contents
of
the
PatientProj,
WebContent
folder,
WEB-INF
folder,
databases
folder,
and
the
hospital
database
until
you
find
the
Statements
folder.
4.
Right-click
the
Statements
folder
and
select
New
>
Select
Statement.
5.
In
the
Statement
Name
text
field,
type
findPatient,
then
click
OK.
This
launches
the
SQL
query
builder.
Next,
build
your
query
accesses
by
doing
the
following:
1.
In
the
Outline
view,
right-click
findPatient,
and
from
the
pop-up
menu
click
Add
Table.
The
Add
Table
dialog
box
opens.
2.
From
the
Table
name
list
select
EXAMPLE.HEALTHCARERECORD,
then
click
OK.
This
specifies
that
the
findPatient
SQL
statement
will
query
the
HEALTHCARERECORD
table.
3.
In
the
Tables
pane
of
the
SQL
query
builder,
select
all
of
the
columns.
Your
screen
should
resemble
this:
14
Now
you
need
to
specify
which
record
you
need
returned.
The
query
will
be
used
to
return
the
health
record
for
a
certain
account
number.
1.
Click
the
Conditions
tab
to
open
the
Conditions
page,
click
the
first
row,
then
click
the
empty
cell
under
the
Column
heading.
2.
Click
the
drop-down
arrow
in
the
cell
and
select
HEALTHCARERECORD.ACCTNO
from
the
list.
3.
Click
the
first
row,
then
click
the
empty
cell
under
the
Operator
heading.
4.
Select
=
from
the
list
5.
Click
the
first
row,
then
click
the
empty
cell
under
the
Value
heading.
6.
Type
:acct
then
press
Enter.
7.
Save
the
query
(File
>
Save).
The
Specify
Variable
Values
dialog
box
opens
8.
Click
the
first
row,
then
click
the
empty
cell
in
the
Value
field
and
type
34.
Press
Enter,
then
click
Finish.
Testing
the
query
Now
that
you
have
created
the
query,
you
should
test
it
to
ensure
that
it
returns
the
correct
result.
To
test
the
query,
do
the
following:
1.
Select
SQL
>
Execute.
The
Specify
Variable
Values
dialog
box
opens.
2.
Click
the
first
row,
then
click
the
empty
cell
in
the
Value
field
and
type
34.
Press
Enter,
then
click
Finish.
The
result
of
the
query
appears
in
the
DB
Output
pane.
If
the
query
was
successful,
the
Status
column
will
indicate
Success.
The
DB
Output
pane
should
look
similar
to
the
following:
Chapter
3.
Developing
the
code
for
the
patient
Web
service
15
Click
Close
to
close
the
Execute
SQL
Statement
dialog
box.
Now
that
you
have
created
the
SQL
query,
continue
the
scenario
with
Creating
the
DADX
file.
Creating
the
DADX
file
To
create
the
DADX
file,
do
the
following:
1.
In
the
Web
perspective
(Window
>
Open
Perspective
>
Other
>
Web),
select
File
>
New
>
Other
>
Web
services
>
DADX
File.
Click
Next.
The
Create
DADX
wizard
opens.
2.
Expand
the
PatientProj,
WebContent,
WEB-INF,
databases,
hospital
and
Statements
folders
and
select
the
findPatient
statement,
then
click
Next.
3.
Click
Next
to
bypass
the
Select
DAD
Files
page.
4.
In
the
DADX
Generation
page,
type
patient.dadx
in
the
File
name
field.
5.
Select
/PatientProj/JavaSource/groups/patientGroup
as
the
output
folder.
6.
Click
Finish.
The
DADX
file
opens
in
the
XML
editor.
Examine
the
file
then
close
the
editor.
Now
that
you
have
generated
the
DADX
file,
continue
the
scenario
with
Creating
the
patient
Web
service.
Creating
the
patient
Web
service
The
patient
information
query
is
implemented
using
a
DADX
Web
service.
The
patient
Web
service
enables
the
hospital
application
to
retrieve
information
about
a
patient
from
the
patient
database
using
a
DB2
query.
The
results
are
returned
to
the
Hospital
server
as
a
SOAP-encoded
XML
document.
The
hospital
application
invokes
a
JSP
file
to
display
the
patient
record.
You
need
to
create
a
server
and
add
the
DB2
driver
(db2java.zip)
from
the
java12
directory
to
the
ws.ext.dirs
server
path
before
you
run
the
Web
service
wizard.
See
the
Application
testing
and
publishing
help
topic
for
instructions
for
creating
a
server
and
adding
drivers
to
your
server
path.
To
create
the
patient
Web
service
from
the
patient.dadx
file,
do
the
following:
1.
Switch
to
the
Web
perspective
(Window
>
Open
Perspective
>
Other
>
Web)
if
necessary.
2.
In
the
Project
Navigator
view,
expand
the
PatientProj
project,
Java
Resources
folder,
and
groups.patientGroup
folder
and
select
the
patient.dadx
file.
3.
Click
File
>
New
>
Other
>
Web
Services.
Select
Web
Service
and
click
Next
to
start
the
Web
service
wizard.
16
4.
In
the
Web
Services
page
of
the
wizard,
ensure
that
DADX
Web
service
is
selected
from
the
Web
service
type
menu.
Ensure
the
Start
Web
service
in
Web
project,
Generate
a
proxy
and
Test
the
generated
proxy
check
boxes
are
selected.
Click
Next.
5.
In
the
Service
Deployment
Configuration
page,
ensure
that
the
proper
server
enviroment
is
selected.
Use
the
Edit
button
to
change
the
server
environment,
if
necessary.
Click
Next.
6.
In
the
Web
Service
DADX
File
Selection
page,
ensure
that
/PatientProj/JavaSource/groups/patientGroup/patient.dadx,
is
specified.
Click
Next.
7.
The
Web
Service
DADX
Group
properties
page
of
the
wizard
is
used
to
update
your
group
properties.
a.
Ensure
the
DB
URL
field
displays
jdbc:db2:hospital.
Ensure
the
DB
URL
field
displays
jdbc:as400://server_name/example,
where
server_name
is
the
name
of
your
iSeries
server.
b.
Enter
your
DB2
user
ID
and
password.
Enter
your
iSeries
user
ID
and
password.
c.
Click
Next.
If
a
Web
services
warning
dialog
regarding
overwriting
files
opens,
click
Yes
to
all.
8.
In
the
Web
Service
Binding
Proxy
Generation
page,
click
the
Show
mappings
check
box.
The
client
proxy
provides
a
remote
procedure
call
interface
to
your
Web
service.
Click
Next
to
accept
the
default
values.
9.
In
the
Web
Service
XML
to
Java
Mappings
page
of
the
wizard,
select
http://tempuri.org/PatientProj/patientGroup/patient.dadx/
XSD:findPatientResult
then
click
Next.
10.
In
the
Web
Service
SOAP
Binding
Mapping
Configuration
page,
review
the
SOAP
binding
mapping
configurations.
Click
Next
to
accept
the
default
values.
11.
In
the
Web
Service
Test
page,
ensure
that
the
Test
the
generated
proxy
check
box
is
selected
and
that
Web
service
sample
JSPs
appears
in
the
Test
facility
text
field.
Click
Finish.
It
may
take
a
few
minutes
for
the
Web
service
to
be
generated.
The
Web
service
is
deployed
to
the
WebSphere
Application
Server
and
an
internal
Web
browser
is
launched
to
demonstrate
the
sample
application.
The
Web
service
will
be
deployed
using
the
WebSphere
Application
Server
unit
test
environment.
The
Server
perspective
automatically
opens
and
a
Server
project
is
created
in
the
Navigator
view.
The
WebSphere
Test
Environment
starts.
Now
that
you
have
created
the
insurance
Web
service,
test
the
method
of
the
patient
DADX
Web
service,
findPatient.
Chapter
3.
Developing
the
code
for
the
patient
Web
service
17
Testing
the
patient
Web
service
The
sample
Web
application
demonstrates
how
to
code
the
proxy.
If
it
is
necessary
to
launch
the
Web
browser,
follow
these
steps:
1.
Ensure
that
you
are
in
the
Server
perspective
(Window
>
Open
Perspective
>
Other
>
Server).
2.
Launch
the
Web
Browser
(click
the
Open
Web
Browser
icon
)
if
necessary
and
type
the
following
address:
http://localhost:port/PatientProjClient/sample/patient/TestClient.jsp
where
port
is
the
port
number
of
your
test
environment.
If
the
pages
appear
broken,
click
the
refresh
icon
on
the
Web
Browser.
To
examine
the
methods
of
the
sample
Web
application:
1.
Click
findPatient_(int)
in
the
Methods
pane.
2.
In
the
acct
field
of
the
Inputs
pane,
type
34
or
35
and
click
Invoke.
The
Result
pane
displays
the
patient
record.
When
you
have
finished
examining
the
findPatient
method
of
the
sample
Web
application,
exit
the
Web
browser.
Any
changes
you
make
to
your
Web
service
can
be
retested
by
returning
to
the
Web
browser.
When
running
a
test
environment,
the
server
is
running
against
the
resources
that
are
in
the
workbench.
The
server
will
pick
up
any
changes
you
make
to
the
Web
project
without
being
restarted.
When
you
have
finished
testing,
close
the
Web
browser.
Next
step
Now
that
youve
developed
the
code
for
the
patient
application,
you
can
create
and
deploy
the
insurance
Web
service.
18
Chapter
4.
Developing
the
code
for
the
insurance
Web
service
In
this
section,
you
will
use
the
XML
tools
in
WebSphere
Studio
to
generate
the
code
required
by
the
insurance
Web
service
by
doing
the
following
steps:
v
Create
the
project
that
will
contain
the
source
files
for
the
insurance
Web
service.
v
Use
the
SQL
query
builder
to
generate
the
SQL
query
that
retrieves
policy
holder
information
from
the
database
in
the
insurance
Web
service
and
generate
the
template
file.
v
Use
the
XML
to
XML
mapping
editor
to
generate
the
XSL
transformation
style
sheet
that
the
insurance
Web
service
uses
to
filter
out
unwanted
data
from
the
health
policy
information
retrieved
from
the
insurance
database.
v
Create
the
insurance
Web
service.
The
insurance
Web
service
processes
the
insurance
claim
submitted
by
the
hospital
application
through
a
Java
bean
Web
service.
The
insurance
bean
performs
a
DB2
SQL
query
and
returns
an
XML
stream.
The
XML
stream
is
then
transformed,
using
standard
XSL
technology,
into
the
XML
document
that
is
returned
to
the
hospital
application.
Creating
the
Web
project
Before
you
can
create
the
insurance
Web
service,
you
need
to
set
up
the
project
that
will
contain
the
code
for
the
Web
service.
You
need
to
add
the
Xalan
and
Xerces
JAR
files
to
the
projects
library
because
the
insurance
bean
uses
DOM
tree
code
from
xerces.jar
and
XSL
transformation
code
from
xalan.jar.
You
do
not
need
to
import
these
JAR
files
into
the
project
because
the
server,
to
which
the
Web
service
is
deployed,
has
a
copy
of
the
Xalan
and
Xerces
JAR
files.
A
Web
project
contains
all
of
the
resources
required
for
the
insurance
Web
service,
such
as
the
InsuranceServiceBean
bean,
the
JSP
files,
the
WSDL
documents,
and
the
deployment
descriptors.
The
Web
service
uses
servlet
technology
which
runs
only
in
a
Web
project.
To
create
the
Web
project
for
the
insurance
company,
do
the
following:
1.
Switch
to
the
Web
Perspective
(Window
>
Open
Perspective
>
Other
>
Web).
2.
On
the
main
menu
bar,
click
File
>
New
>
Dynamic
Web
Project.
3.
In
the
Project
name
entry
field,
type
InsuranceProj.
Click
Finish.
4.
Right-click
the
project
to
open
the
pop-up
menu
for
the
InsuranceProj
and
select
Properties.
5.
In
the
Properties
window,
select
Java
Build
Path
under
the
Libraries
tab.
6.
Click
Add
Variable.
Press
and
hold
the
Ctrl
key
and
select
XERCES_API_JAR,
and
SOAPJAR.
Click
OK
to
close
the
dialog.
7.
Click
OK.
Importing
the
JAR
file
The
sqltoxml.jar
file
contains
the
SQL
to
XML
code
required
by
the
insurance
bean.
The
sqltoxml.jar
file
takes
an
SQL
statement
as
input
and
generates
an
XML
document
based
on
the
results
of
the
SQL
statement.
Import
the
JAR
file
by
doing
the
following:
Copyright
IBM
Corp.
2000,
2003
19
1.
In
the
Project
Navigator,
expand
InsuranceProj
and
select
the
WebContent/WEB-INF/lib
folder.
2.
From
the
workbench,
click
File
>
Import.
The
Import
wizard
opens.
3.
In
the
wizard,
select
File
system
from
the
Select
an
import
source
list,
then
click
Next.
4.
Click
the
Browse
button,
and
browse
to:
WS_Installdir\wstools\eclipse\plugins\com.ibm.etools.sqltoxml_version\jars.
Click
OK.
5.
If
necessary,
click
the
jars
folder
to
display
the
files,
without
selecting
the
check
box.
Select
the
sqltoxml.jar
file
check
box.
6.
In
the
Folder
text
field,
ensure
that
the
following
is
specified:
InsuranceProj/WebContent/WEB-INF/lib
1.
Click
Finish.
The
JAR
file
is
imported
into
the
InsuranceProj
project.
If
you
want
to
see
the
imported
file,
select
the
Project
Navigator
view
and
expand
the
lib
folder.
Generating
the
source
code
for
the
database
query
The
insurance
service
bean
is
implemented
by
using
SQL-to-XML
code
to
perform
a
DB2
query.
The
XML
output
from
the
SQL-to-XML
code
is
transformed
using
standard
XSL
transformation
technology.
Important:
You
can
either
import
the
SQL
query
and
XSL
file
into
the
insurance
Web
project
or
you
can
create
the
SQL
query
and
XSL
file
using
the
SQL
query
builder
and
the
XML
to
XML
mapping
editor:
v
To
import
the
source
files,
follow
the
directions
in
Importing
the
source
files
below,
then
skip
the
directions
in
Importing
the
DTD
file
and
insurance
bean,
Creating
the
SQL
query,
and
Generating
the
XSL
file.
v
Alternatively,
to
generate
the
source
files,
skip
the
Importing
the
source
files
section
and
follow
the
directions
in
Importing
the
DTD
file
and
insurance
bean,
Creating
the
SQL
query,
and
Generating
the
XSL
file.
The
code
that
you
import
or
generate
is
required
in
order
to
query
the
insurance
database
and
return
the
health
policy
information.
20
Importing
the
source
files
The
source
code
for
the
insurance
Web
service
is
provided
for
you.
To
import
the
source
files:
1.
Switch
to
the
Web
Perspective
(Window
>
Open
Perspective
>
Other
>
Web)
if
necessary.
2.
In
the
Project
Navigator
select
the
InsuranceProj
folder.
3.
Click
File
>
Import
to
open
the
Import
wizard.
4.
Click
File
system
to
import
the
resources
from
the
local
file
system.
Click
Next.
5.
To
enter
the
directory,
click
Browse
to
locate
and
select:
WS_Installdir\wstools\eclipse\plugins\com.ibm.etools.webservice_version\samples\
hospital\InsuranceProj
6.
Click
OK.
7.
Click
Select
All
to
import
the
source
files
and
folders.
8.
In
the
Folder
text
field,
ensure
that
the
InsuranceProj
folder
is
specified,
then
click
Finish
to
import
the
folders
and
files,
and
close
the
wizard.
Now
that
you
have
imported
the
SQL
query
and
XSL
file,
continue
the
scenario
with
Creating
the
insurance
Web
service.
Importing
the
DTD
file
and
insurance
bean
A
DTD
and
insurance
bean
have
been
provided
to
simplify
the
scenario.
After
you
import
the
file
and
bean,
you
can
double-click
them
to
look
at
the
source
if
you
want
to
see
how
they
were
written.
Both
of
these
files
are
required
later
in
the
scenario.
To
import
the
files,
do
the
following:
1.
Switch
to
the
Web
Perspective
(Window
>
Open
Perspective
>
Other
>
Web)
if
necessary.
2.
In
the
Project
Navigator
view,
under
InsuranceProj,
select
the
Java
Resources
folder.
3.
Click
File
>
Import
to
open
the
Import
wizard.
4.
Click
File
system
to
import
the
resources
from
the
local
file
system.
Click
Next.
5.
To
enter
the
directory,
click
Browse
to
locate
and
select
WS_Installdir\wstools\eclipse\plugins\com.ibm.etools.webservice_version\
samples\hospital\InsuranceProj\JavaSource
Click
OK.
6.
In
the
Import
wizard,
select
the
check
box
beside
the
JavaSource
folder.
7.
Expand
the
JavaSource
folder
and
click
the
query_info
folder.
The
query_info
folder
contains
the
DTD
file
that
you
will
use
later
in
the
scenario.
8.
Clear
the
checkboxes
beside
all
files
except
the
Response.dtd
file.
9.
Ensure
that
the
com
folder
is
selected.
The
com
folder
contains
the
bean
required
for
a
Web
service
that
you
will
create
later
in
the
scenario.
10.
In
the
Folder
text
field,
ensure
that
the
following
path
is
specified:
InsuranceProj/JavaSource
11.
Ensure
that
the
Create
complete
folder
structure
radio
button
is
not
selected.
12.
Click
Finish
to
import
the
folders
and
files
and
close
the
wizard.
Now
that
you
have
imported
the
bean,
continue
the
scenario
with
Creating
the
SQL
query.
Chapter
4.
Developing
the
code
for
the
insurance
Web
service
21
Creating
the
SQL
query
The
insurance
database
(INSURE)
contains
two
tables:
CLIENTINFO
which
contains
information
about
the
clients,
and
POLICYINFO
which
contains
information
about
the
policies.
You
will
create
an
SQL
SELECT
statement
that
uses
a
social
security
number
(SSN)
to
query
the
tables
in
the
database.
You
use
the
SQL
query
builder
tool
to
define
the
query.
To
create
the
SQL
query,
you
need
to
do
the
following:
v
Define
the
database
connection
v
Define
the
SQL
statement
v
Test
the
query
v
Generate
the
template
file
The
following
sections
provide
details
about
each
of
these
tasks.
Defining
the
database
connection
Define
the
connection
to
the
insurance
database
by
doing
the
following:
1.
Select
Window
>
Open
Perspective
>
Other
>
Data.
2.
Right-click
anywhere
in
the
DB
Servers
pane,
then
click
New
Connection.
The
New
Connection
wizard
opens.
3.
In
the
Connection
Name
entry
field,
type
Insurance_connection.
4.
In
the
Database
entry
field,
type
insure.
In
the
Database
entry
field,
type
example.
5.
In
the
User
ID
and
Password
fields,
type
your
DB2
user
ID
and
password.
6.
In
the
Database
vendor
type
field,
ensure
that
the
correct
database
driver
is
selected.
7.
In
the
JDBC
driver
field,
ensure
that
the
correct
JDBC
driver
is
selected.
8.
In
the
Class
location
field,
ensure
that
the
path
to
your
to
your
JDBC
driver
class
(in
db2java.zip)
is
correct.
In
the
Class
location
field,
ensure
that
the
path
to
your
JDBC
driver
class
(jt400.jar)
is
correct.
9.
Click
Finish.
A
connection
to
the
insurance
database
(INSURE)
is
defined.
Now
that
you
have
defined
the
database
connection,
you
need
to
copy
the
connection
information
to
the
workspace
by
doing
the
following
steps:
1.
In
the
DB
Servers
pane,
expand
Insurance_connection
and
right-click
insure(jdbc:db2:insure).
From
the
pop-up
menu
select
Import
to
Folder.
The
Import
to
Folder
dialog
opens.
In
the
DB
Servers
pane,
expand
Insurance_connection
and
right-click
example(jdbc:as400://server_name).
The
Import
to
Folder
dialog
opens.
2.
Click
Browse
and
select
the
InsuranceProj
folder.
3.
Click
OK,
then
click
Finish.
4.
Click
Yes
to
confirm
the
creation
of
the
databases
folder.
22
Defining
the
SQL
statement
The
SQL
statement
specifies
the
tables
and
fields
that
are
queried
in
the
insurance
database,
and
the
conditions
that
govern
the
query.
To
define
the
SQL
statement,
you
first
give
the
statement
a
name:
1.
Make
sure
you
are
in
the
Data
perspective
(Window
>
Open
Perspective
>
Other
>
Data)
2.
Click
the
Data
Definition
tab.
3.
Expand
the
contents
of
the
InsuranceProj
project,
Web
Content
folder,
WEB-INF
folder,
databases
folder
and
the
insure
database
until
you
find
the
Statements
folder.
4.
Right-click
the
Statements
folder
and
select
New
>
Select
Statement.
5.
In
the
Statement
Name
text
field,
type
FindHealthPolicy,
then
click
OK.
This
launches
the
SQL
query
builder.
Note:
Ensure
that
you
specify
the
correct
case
when
typing
FindHealthPolicy.
For
example,
if
you
type
findHealthPolicy
instead
of
FindHealthPolicy
with
an
upper
case
F,
the
application
will
fail.
Next,
specify
the
tables
that
the
query
accesses:
1.
In
the
Outline
view,
right-click
FindHealthPolicy,
and
from
the
pop-up
menu
click
Add
Table.
The
Add
Table
dialog
box
opens.
2.
From
the
Table
name
list
select
EXAMPLE.POLICYINFO,
then
click
OK.
This
specifies
that
the
FindHealthPolicy
SQL
statement
will
query
the
POLICYINFO
table.
3.
In
the
Outline
pane,
right-click
FindHealthPolicy,
and
from
the
pop-up
menu
click
Add
Table.
The
Add
Table
dialog
box
opens.
4.
In
the
Table
name
list
select
EXAMPLE.CLIENTINFO,
then
click
OK.
This
specifies
that
the
FindHealthPolicy
SQL
statement
will
also
query
the
CLIENTINFO
table.
The
Tables
pane
(the
pane
that
contains
a
graphical
representation
of
the
database
tables)
of
the
SQL
query
builder
should
look
like
this:
You
can
resize
the
Tables
pane
by
hovering
over
the
bottom
corner
of
the
pane
with
your
mouse
until
the
cursor
turns
into
an
arrow.
Click
and
drag
to
resize.
Now
you
need
to
specify
that
the
query
combines
information
from
both
the
POLICYINFO
and
CLIENTINFO
tables
for
a
given
account
number
by
doing
the
following:
Chapter
4.
Developing
the
code
for
the
insurance
Web
service
23
1.
In
the
Graph
pane,
click
and
hold
the
mouse
button
on
ACCTNO
from
the
POLICYINFO
table.
2.
Drag
the
mouse
pointer
to
the
ACCTNO
in
the
CLIENTINFO
table.
Ensure
that
the
check
box
next
to
ACCTNO
remains
clear.
Finally,
specify
that
the
SQL
query
should
retrieve
health
policy
information
for
the
given
account
number
by
doing
the
following:
1.
In
the
Graph
pane,
select
all
of
the
fields
in
the
POLICYINFO
table
by
clicking
each
check
box
next
to
each
field.
2.
Using
the
same
method,
select
the
following
fields
in
the
CLIENTINFO
table:
v
SSN
v
ADDRLINE
v
CITY
v
STATE
v
COUNTRY
3.
In
the
Conditions
page
(click
the
Conditions
tab
to
open
this
page),
select
the
first
row,
then
click
the
empty
field
below
the
Column
heading.
The
field
displays
a
down
arrow
on
the
right
side.
4.
Click
the
down
arrow,
and
from
the
pop-up
list
click
CLIENTINFO.SSN.
5.
Click
the
empty
field
below
the
Operator
heading,
then
click
the
down
arrow.
6.
From
the
pop-up
list,
select
=.
7.
Click
the
empty
field
below
the
Value
heading,
type
:SSN
and
press
Enter.
Make
sure
that
you
included
the
colon
with
this
string.
SSN
is
a
variable
that
will
contain
at
run-time
the
social
security
number
for
the
query.
8.
Click
the
empty
field
below
the
AND/OR
heading,
then
click
the
down
arrow.
9.
From
the
pop-up
list,
select
AND.
10.
Select
the
next
empty
row.
Click
the
field
below
the
Column
heading,
then
click
the
down
arrow.
11.
From
the
pop-up
list,
click
POLICYINFO.POLICYTYPE.
12.
Click
the
next
empty
field
below
the
Operator
heading,
then
click
the
down
arrow.
13.
From
the
pop-up
list,
select
=.
14.
Click
the
next
empty
field
below
the
Value
heading,
type
health
and
press
Enter.
Make
sure
that
you
included
the
single
quotes
in
this
string.
This
value
specifies
that
the
query
retrieves
health
policy
information
for
the
given
social
security
number.
Your
query
should
resemble
the
following
screen:
24
Testing
the
query
Now
that
you
have
created
the
query,
you
should
test
it
to
ensure
that
it
returns
the
correct
result.
To
test
the
query,
do
the
following:
1.
Select
SQL
>
Execute.
2.
Click
Execute
in
the
Execute
SQL
Statement
dialog.
The
Specify
Variable
Values
dialog
box
opens.
3.
In
the
Value
field,
replace
NULL
with
the
text
123-45-6789.
Include
the
single
quotation
marks.
Press
Enter,
then
click
Finish.
If
the
query
is
successful,
the
result
in
the
DB
Output
pane
looks
like
this:
Save
the
query
(File
>
Save).
When
you
save
the
query,
the
Specify
Variable
Values
dialog
box
will
open.
In
the
Value
field,
replace
NULL
with
the
text
123-45-6789.
Include
the
single
quotation
marks.
Press
Enter,
then
click
Finish
to
save
the
query.
Generating
the
template
file
The
template
file
contains
the
SQL
statement
and
other
configuration
information
related
to
the
query.
The
insurance
Web
service
uses
this
file
to
execute
the
query.
You
need
to
save
the
SQL
statement
in
this
file
by
doing
the
following:
1.
In
the
Outline
view,
right-click
FindHealthPolicy,
and
from
the
pop-up
menu
click
Generate
new
XML.
The
XML
from
SQL
wizard
opens.
Chapter
4.
Developing
the
code
for
the
insurance
Web
service
25
2.
In
the
wizard,
accept
the
default
values
and
ensure
that
Generate
query
template
file
is
selected.
3.
Ensure
that
the
Template
file
entry
field
contains:
FindHealthPolicy.xst.
4.
In
the
Output
folder
entry
field,
specify
the
following
directory:
/InsuranceProj/JavaSource/query_info
then
click
OK.
5.
Click
Finish.
The
Specify
Variable
Values
dialog
box
opens.
6.
Click
the
first
row,
then
click
the
Value
field.
Replace
the
NULL
value
with
123-45-6789.
Include
the
single
quotation
marks.
Press
Enter,
then
click
Finish.
7.
Switch
to
the
Navigator
view
to
view
the
template
file
FindHealthPolicy.xst.
Close
the
SQL
query
builder.
Now
that
you
have
created
the
SQL
query,
continue
with
Generating
the
XSL
file.
Generating
the
XSL
file
To
create
the
response
XML
document
that
the
insurance
Web
service
returns
to
the
hospital
application,
the
insurance
Web
service
must
transform
the
health
policy
information
into
the
claim
response
by
filtering
out
unwanted
data.
The
insurance
Web
service
performs
this
transformation
using
an
XSL
transformation
style
sheet
(response.xsl).
You
generate
the
style
sheet
using
the
XML
to
XML
mapping
editor.
The
XML
to
XML
mapping
editor
generates
the
style
sheet
based
on
the
mapping
between
a
source
and
a
target
XML
document.
Mapping
identifies
what
elements
in
the
source
XML
document
will
appear
in
the
target
XML
document.
The
source
XSD
for
the
health
policy
information
is
FindHealthPolicy.xsd,
and
the
target
DTD
that
defines
the
claim
response
is
Response.dtd.
Response.dtd
is
already
created
for
you
and
you
imported
it
in
a
previous
step.
You
will
create
the
FindHealthPolicy.dtd.
You
will
use
the
XML
mapping
editor
to
map
the
source
and
target
elements
before
generating
the
style
sheet.
First,
you
need
to
open
the
source
and
target
XML
files
by
doing
the
following:
1.
Switch
to
the
XML
perspective
(Window
>
Open
Perspective
>
Other
>
XML).
2.
In
the
Navigator
view,
expand
the
InsuranceProj,
JavaSource,
and
query_info
folders.
3.
In
the
query_info
folder
right-click
FindHealthPolicy.xsd.
Click
Generate
>
DTD.
4.
Accept
the
default
values
and
click
Finish.
FindHealthPolicy.dtd
is
generated
into
the
query_info
folder.
5.
Select
the
query_info
folder.
From
the
workbench,
click
File
>
New
>
XML
>
XML
to
XML
Mapping
and
click
Next.
The
XML
to
XML
Mapping
dialog
box
opens.
6.
In
the
Folder
text
field,
ensure
the
following
is
specified:
InsuranceProj/
JavaSource/query_info.
The
File
name
field
specifies
the
mapping
session
name.
Leave
the
default
as
is,
and
click
Next.
The
New
XML
to
XML
Mapping
wizard
opens.
7.
Expand
the
InsuranceProj,
JavaSource
and
query_info
folders
and
select
FindHealthPolicy.dtd.
26
8.
Click
>
to
add
the
file
to
the
Selected
Files
pane.
9.
Click
Next.
The
Specify
Target
XML,
DTD,
or
XSD
File
dialog
box
opens.
10.
Expand
the
InsuranceProj,
JavaSource,
and
query_info
folders
and
select
Response.dtd.
11.
Click
Next.
The
Root
Element
dialog
box
opens.
12.
In
the
Target
root
element
field,
ensure
that
response
is
specified.
13.
In
the
Source
root
elements
field,
ensure
that
SQLResult
is
specified.
14.
Click
Finish.
This
launches
the
XML
to
XML
mapping
editor.
The
source
DTD
and
target
DTDs
appear
in
the
center
pane
of
the
workbench,
and
when
expanded
look
similar
to
the
following
diagram:
The
next
step
is
to
map
the
source
and
target
elements
by
doing
the
following:
1.
Expand
the
element
in
the
Source
and
Target
panes.
2.
Select
POLICYNUM
in
both
the
Source
and
Target
panes,
then
right-click
on
the
Target
pane
and
select
Create
Mapping.
The
mapping
specifies
that
the
POLICYNUM
element
in
the
health
policy
information
will
also
appear
in
the
claim
response.
Notice
that
the
Overview
pane
is
updated
to
show
the
mapping
between
the
source
and
target
elements.
You
can
also
create
a
mapping
by
selecting
POLICYNUM
in
the
Source
pane
and
dragging
the
mouse
pointer
to
POLICYNUM
in
the
Target
pane.
3.
Follow
the
same
procedure
as
in
step
2
to
map
the
following
elements
in
the
source
DTD
file
to
the
equivalent
target
DTD:
v
SSN
v
ACCTNO
v
COVERAGEAMOUNT
v
ADDRLINE
v
CITY
v
STATE
v
COUNTRY
The
elements
in
the
source
file
that
were
not
mapped
to
any
elements
in
the
target
DTD
will
not
appear
in
the
claim
response
that
is
returned
to
the
hospital
application.
The
Overview
pane
should
resemble
the
following
screen:
Chapter
4.
Developing
the
code
for
the
insurance
Web
service
27
Now
that
you
have
mapped
the
elements,
you
can
generate
the
transformation
style
sheet
by
doing
the
following:
1.
Select
Mapping
>
Generate
XSLT
Script.
The
Generate
XSLT
Script
wizard
opens.
2.
Select
the
InsuranceProj/JavaSource/query_info
folder.
3.
Click
Finish.
The
style
sheet
is
generated,
and
opens
in
the
XML
editor
for
your
review.
4.
Close
the
file
when
you
have
completed
the
review.
Save
the
mapping
session
by
selecting
File
>
Save,
then
close
the
file.
Now
that
you
have
generated
the
XSL
transformation
file,
continue
the
scenario
with
Creating
the
insurance
Web
service.
Creating
the
insurance
Web
service
The
insurance
Web
service
enables
the
hospital
application
to
generate
an
insurance
claim
based
on
the
results
of
the
patient
information.
The
insurance
Web
service
processes
the
claim,
and
returns
a
claim
response
to
the
hospital
application
that
invokes
a
JSP
to
display
the
results
of
the
claim.
To
create
the
insurance
Web
service,
do
the
following:
1.
Switch
to
the
Web
Perspective
(Window
>
Open
Perspective
>
Other
>
Web)
if
necessary.
2.
In
the
Project
Navigator,
expand
the
InsuranceProj
folder,
Java
Resources
folder,
com.ibm.b2b.examples.insurance
package,
and
select
the
InsuranceServiceBean.java
file.
3.
Click
File
>
New
>
Other
>
Web
services.
Click
Web
Service
and
click
Next
to
start
the
Web
service
wizard.
4.
In
the
Web
Services
page
of
the
wizard,
ensure
that
the
Java
bean
Web
service
is
selected
as
the
the
Web
service
type,
then
ensure
the
Start
Web
service
in
Web
project
and
Generate
a
proxy
and
Test
the
generated
proxy
check
boxes
are
selected.
Ensure
that
the
the
Overwrite
files
without
warning
check
box
is
selected.
Click
Next.
5.
In
the
Server-Side
Deployment
Selection
section
of
the
Service
Deployment
Configuration
page,
click
Edit,
and
select
IBM
SOAP
as
the
Web
service
run
time.
Also,
ensure
that
the
proper
server
is
selected.
Click
OK.
In
the
Client-Side
Enviroment
Selection
section
of
the
Service
Deployment
Configuration
page,
ensure
that
IBM
SOAP
is
the
Web
service
run
time
and
that
the
proper
server
is
selected.
Click
Next.
6.
In
the
Web
Service
Java
Bean
Selection
page
ensure
that
the
InsuranceServiceBean
is
selected.
Click
Next.
28
7.
The
Web
Service
Java
Bean
Identity
page
of
the
wizard
specifies
your
Web
service
URI,
scope,
and
the
names
of
the
generated
files.
Click
Next
to
accept
the
default
values.
8.
The
Web
Service
Java
Bean
Methods
page
of
the
wizard
displays
a
summary
of
methods
in
your
bean.
The
InsuranceServiceBean
bean
has
one
method
that
is
selected
by
default.
You
can
specify
input
encoding
and
output
encoding
styles.
Ensure
that
SOAP
encoding
for
the
Input
encoding
is
selected
and
Literal
XML
encoding
for
the
Output
encoding
is
selected.
9.
Select
the
Show
server
(Java
to
XML)
type
mappings
check
box,
then
click
Next.
10.
In
the
Web
Service
Java
to
XML
Mappings
page,
review
your
Web
service
type
mappings.
Click
Next
to
accept
the
default
values.
11.
In
the
Web
Service
Binding
Proxy
Generation
page,
review
the
bindings
that
you
will
use
to
generate
a
Web
service
proxy.
The
client
proxy
provides
a
remote
procedure
call
interface
to
your
Web
service.
The
folder
of
the
Java
client
proxy
defaults
to
/InsuranceProjClient/JavaSource.
The
name
of
the
fully
qualified
Java
class
defaults
to
proxy.soap.InsuranceServiceBeanProxy.
Click
the
Show
mappings
check
box,
then
click
Next.
12.
In
the
Web
Service
XML
to
Java
Mappings
page,
review
your
Web
service
client
type
mappings
then
click
Next
to
accept
the
default
values.
13.
In
the
Web
Service
SOAP
Binding
Mapping
Config
page,
click
Next
to
accept
the
default
values.
14.
In
the
Web
service
Test
page,
ensure
that
Test
the
Generated
Proxy
is
checked
and
Web
service
sample
JSPs
are
selected.
Click
Finish
to
accept
the
remaining
default
values
and
to
open
the
Web
browser.
The
sample
Web
application
demonstrates
how
to
code
a
JSP
in
terms
of
the
proxy
file.
It
may
take
a
few
minutes
for
the
Web
service
to
be
generated.
The
Web
service
is
deployed
to
the
WebSphere
Application
Server
and
an
internal
Web
browser
is
launched
to
demonstrate
the
sample
application.
The
Web
service
will
be
deployed
using
the
WebSphere
Application
Server
unit
test
environment.
The
Server
perspective
automatically
opens
and
a
Server
project
is
created
in
the
Navigator
view.
The
WebSphere
Test
Environment
starts.
Now
that
you
have
created
the
insurance
Web
service,
test
the
method
of
the
InsuranceServiceBean.
Testing
the
insurance
Web
service
The
sample
Web
application
demonstrates
how
to
code
the
proxy.
If
it
is
necessary
to
launch
the
Web
browser,
follow
these
steps:
1.
Ensure
that
you
are
in
the
Server
perspective
(Perspective
>
Open
>
Other
>
Server).
2.
Launch
the
Web
Browser
(click
the
Open
Web
Browser
icon
)
and
type
the
following
address:
http://localhost:port/InsuranceProjClient/sample
/InsuranceServiceBean/TestClient.jsp
where
port
is
the
port
number
of
your
test
environment.
To
examine
the
methods
of
the
sample
Web
application:
1.
Click
processClaim
in
the
Methods
pane.
Chapter
4.
Developing
the
code
for
the
insurance
Web
service
29
2.
In
the
ssn
field
of
the
Inputs
pane,
type
123-45-6789
and
click
Invoke.
The
Result
pane
displays
the
patient
record
as
an
XML
document.
Your
browser
should
look
similar
to
the
following:
When
you
have
finished
examining
the
processClaim
method
of
the
sample
Web
application,
exit
the
Web
browser.
Any
changes
you
make
to
your
Web
service
can
be
retested
by
returning
to
the
Web
browser.
When
running
a
test
environment,
the
server
is
running
against
the
resources
that
are
in
the
workbench.
Any
changes
you
make
to
the
Web
project
are
picked
up
without
being
restarted.
When
you
have
finished
testing
close
the
Web
browser.
Next
step
Now
that
you
have
developed
the
code
for
the
insurance
Web
service,
you
can
do
the
same
for
the
hospital
Web
service.
30
Chapter
5.
Creating
and
deploying
the
hospital
application
In
this
section,
you
will
import
the
source
files
for
the
hospital
application
by
doing
the
following:
v
Create
the
Web
project
that
will
contain
the
source
files
for
the
hospital
application
v
Import
the
Java
beans,
JAR
files,
JSP
files,
and
HTML
files
for
the
hospital
application.
The
hospital
application
is
implemented
with
Java
servlets,
JSP
files,
and
HTML
files.
The
main
function
of
the
hospital
application
is
to
provide
a
user
interface
to
the
client.
Creating
the
project
You
should
have
already
set
up
the
development
environment
for
the
insurance
and
patient
Web
services.
If
not,
refer
to
the
instructions
for
setting
up
the
Web
services.
Before
you
can
create
the
hospital
application,
you
need
to
set
up
the
project
that
will
contain
the
code
for
the
application.
All
of
the
files
for
the
hospital
application
have
been
provided
for
you.
The
code
is
used
to
provide
a
user
interface
to
the
client
and
includes
beans,
JAR
files,
JSP
files,
and
HTML
files
for
the
hospital
application.
To
create
the
Web
project,
do
the
following:
1.
Switch
to
the
Web
Perspective
(Window
>
Open
Perspective
>
Other
>
Web)
if
necessary.
2.
From
the
workbench,
click
File
>
New
>
Dynamic
Web
Project.
3.
Type
HospitalProj
in
the
Project
name
entry
field.
Click
Finish.
4.
In
the
Repair
Server
Configuration
dialog,
click
OK
to
add
HospitalProj
to
the
DefaultEAR
project.
5.
Right-click
the
project
and
select
Properties.
6.
Select
the
Java
Build
Path
page
and
click
the
Libraries
tab.
7.
Click
Add
Variable
to
add
the
following
JAR
files
(hold
down
the
Ctrl
key
to
select
multiple
files):
SOAPJAR
XERCES_API_JAR
8.
Click
OK.
9.
Click
OK
to
close
the
Properties
dialog.
Importing
the
XSD
JAR
files
The
hospital
client
code
receives
XML
data
from
both
the
patient
Web
service
and
the
insurance
Web
service.
The
Web
services
wizard
will
create
Java
code
to
programmatically
extract
the
data
from
the
XML
data
streams.
The
generated
code
requires
the
XSD
JAR
files.
To
import
the
XSD
JAR
files,
do
the
following:
Copyright
IBM
Corp.
2000,
2003
31
1.
In
the
Project
Navigator
view,
select
the
HospitalProj\WebContent\WEB-
INF\lib
folder.
2.
From
the
workbench,
click
File
>
Import.
The
Import
wizard
opens.
3.
In
the
wizard,
select
File
system
from
the
Select
an
import
source
list,
then
click
Next.
4.
In
the
Directory
text
field,
specify
the
following
location
of
the
source
code.
Use
the
Browse
button
if
necessary:
WS_Installdir\wstools\eclipse\plugins\com.ibm.etools.xsdmodel_version\jars
5.
Click
OK.
6.
Select
the
xsdbeans.jar
file.
7.
In
the
Folder
text
field,
ensure
the
following
is
specified:
HospitalProj/WebContent/WEB-INF/lib.
If
the
correct
folder
is
not
specified,
use
the
Browse
button
to
specify
the
folder.
8.
Click
Finish.
The
source
code
is
imported
into
the
HospitalProj
project.
9.
Repeat
steps
2
through
5,
to
select
WS_Installdir\wstools\eclipse\plugins\
com.ibm.etools.xsd.bean_version\runtime
10.
Select
xsd.bean.runtime.jar.
11.
Click
Finish.
The
source
code
is
imported
into
the
HospitalProj
project.
Once
you
have
imported
the
XSD
JAR
files,
you
will
import
the
client
code.
Importing
the
client
code
In
order
for
the
hospital
to
receive
payment
for
a
patients
visit,
the
hospital
must
submit
a
claim
to
the
insurance
company.
The
hospital
application
first
retrieves
information
about
a
patient
from
the
patient
database,
invoking
a
JSP
file
to
display
the
patient
record.
Additional
information
about
the
patient
is
entered
on
the
page,
returned
to
the
patient
database,
and
sent
as
a
claim
to
the
insurance
Web
service
for
processing.
The
insurance
Web
service
processes
the
claim,
and
returns
a
claim
response
to
the
hospital
application
invoking
another
JSP
to
display
the
results
of
the
claim.
The
source
code
for
the
hospital
client
application
is
provided.
You
need
to
import
the
source
code
into
HospitalProj
by
doing
the
following:
1.
In
the
Project
Navigator
view,
select
the
HospitalProj
folder.
2.
From
the
workbench,
click
File
>
Import.
The
Import
wizard
opens.
3.
In
the
wizard,
select
File
system
from
the
Select
import
source
list,
then
click
Next.
4.
In
the
Directory
text
field,
specify
the
following
location
of
the
source
code.
Use
the
Browse
button
if
necessary.
WS_Installdir\wstools\eclipse\plugins\com.ibm.etools.webservice_version\samples\
hospital\HospitalProj
5.
Click
OK.
6.
Click
Select
All
and
select
Overwrite
existing
resources
without
warning.
7.
In
the
Folder
text
field,
ensure
HospitalProj
is
specified.
If
the
correct
folder
is
not
specified,
use
the
Browse
button
to
specify
the
project.
8.
Click
Finish.
The
source
code
is
imported
into
the
HospitalProj
project.
Note:
In
the
Tasks
view,
you
can
safely
ignore
any
errors
or
warnings
that
describe
broken
links
in
the
HospitalProj
project.
32
Copy
the
proxies
from
the
PatientProjClient
and
InsuranceProjClient
projects.
In
a
real
world
example,
you
would
run
the
Web
Services
Client
Wizard
on
the
WSDL
for
each
of
the
Web
services
to
generate
the
proxies.
To
simplify,
you
will
copy
the
proxies
from
the
PatientProjClient
and
InsuranceProjClient
projects
to
the
HospitalProj
project.
To
copy
the
proxy
from
the
PatientProjClient
project:
1.
Switch
to
the
Resource
perspective
(Window
>
Open
Perspective
>
Other
>
Resource)
2.
In
the
Navigator
view,
expand
the
PatientProjClient
project
and
Java
Resources
folders.
3.
Select
both
org.tempuri.patientproj.patientgroup.patient.dadx.xsd
and
proxy.soap
folders.
4.
Right-click
and
click
Copy
from
the
pop-up
menu.
5.
Expand
the
HospitalProj
project.
6.
Right-click
the
Java
Resources
folder
and
click
Paste
from
the
pop-up
menu.
7.
When
asked
if
you
want
to
overwrite
the
existing
file,
click
Yes
to
all.
To
copy
the
proxy
from
the
InsuranceProjClient
project:
1.
In
the
Navigator
view,
expand
the
InsuranceProjClient
project
and
Java
Resources
folders.
2.
Right-click
the
proxy.soap
folder
and
click
Copy
from
the
pop-up
menu.
3.
Expand
the
HospitalProj
project.
4.
Right-click
the
Java
Resources
folder
and
click
Paste
from
the
pop-up
menu.
5.
When
asked
if
you
want
to
overwrite
the
existing
file,
click
Yes
to
all.
Next
step
Everything
is
now
ready
for
you
to
test
the
hospital
application
sample
application
using
your
Web
browser.
Chapter
5.
Creating
and
deploying
the
hospital
application
33
34
Chapter
6.
Running
the
hospital
sample
application
and
testing
the
Web
service
You
run
the
sample
application
the
same
way
a
hospital
employee
would
from
your
Web
browser.
You
start
by
entering
a
patient
account
number
in
the
Patient
claim
entry
pane.
You
then
enter
additional
patient
information
into
the
Patient
claim
history
pane.
The
Claim
results
pane
displays
the
results.
The
following
sections
take
you
through
these
steps.
Submitting
the
claim
To
start
or
restart
WebSphere
Test
Environment:
1.
In
the
Servers
perspective
(Window
>
Open
Perspective
>
Server)
,
click
the
Servers
tab
at
the
bottom
of
the
Servers
view.
2.
If
the
server
is
not
started,
right-click
the
server
instance
and
select
Start.
If
the
server
is
started,
right-click
the
server
instance
and
select
Restart.
3.
If
the
Server
Selection
dialog
opens,
click
Advanced.
Click
Finish
to
close
the
Server
Selection
dialog.
To
get
to
the
first
page
of
the
user
interface,
do
the
following:
1.
Right-click
the
HospitalProj/WebContent/index.html
file
and
select
Run
on
server.
2.
Select
the
server,
then
click
Finish.
The
following
Web
page
is
displayed:
3.
In
the
Account
number
entry
field
of
the
Patient
claim
entry
pane,
type
one
of
the
following
account
numbers:
34
or
35.
4.
Click
Submit.
If
you
typed
account
number
34,
the
hospital
application
returns
the
following
Patient
claim
history
page
with
the
patient
information:
Copyright
IBM
Corp.
2000,
2003
35
5.
Fill
in
the
following
fields
in
the
Claim
result
page:
Visit
description:
Name
of
doctor
seen:
Visit
cost:
6.
Click
Submit.
The
claim
is
sent
to
the
insurance
application
for
processing.
Viewing
the
claim
response
The
claim
response
that
the
insurance
application
returns
consists
of
two
parts,
as
shown
in
the
following
illustration:
36
The
response
includes
information
from
different
sources:
v
The
claim
amount
that
was
entered
by
the
hospital
employee
and
then
submitted
to
the
insurance
application
for
processing
v
Patient
information,
including
the
address,
policy
number,
and
coverage
information
that
was
retrieved
from
the
insurance
database
by
the
insurance
application
All
of
this
information
is
merged
by
the
insurance
application
to
produce
the
claim
response.
Summary
Now
that
you
have
successfully
run
the
sample
application,
you
have
completed
developing
the
scenario.
You
have
gone
through
the
process
of
developing
an
XML
application,
from
initial
preparation,
through
code
development,
to
testing.
You
used
the
XML
and
Web
service
tools
to
generate
the
code
required
by
the
sample
application,
including
generated
Java
classes,
the
XSL
transformation
style
sheet,
and
the
SQL
query.
The
final
step
in
this
process
would
be
to
deploy
each
Web
service
on
their
respective
Web
application
servers,
such
as
WebSphere
Application
Server.
Chapter
6.
Running
the
hospital
sample
application
and
testing
the
Web
service
37
38
Notices
Note
to
U.S.
Government
Users
Restricted
Rights
-
Use,
duplication
or
disclosure
restricted
by
GSA
ADP
Schedule
Contract
with
IBM
Corp.
This
information
was
developed
for
products
and
services
offered
in
the
U.S.A.
IBM
may
not
offer
the
products,
services,
or
features
discussed
in
this
document
in
other
countries.
Consult
your
local
IBM
representative
for
information
on
the
products
and
services
currently
available
in
your
area.
Any
reference
to
an
IBM
product,
program,
or
service
is
not
intended
to
state
or
imply
that
only
that
IBM
product,
program,
or
service
may
be
used.
Any
functionally
equivalent
product,
program,
or
service
that
does
not
infringe
any
IBM
intellectual
property
right
may
be
used
instead.
However,
it
is
the
users
responsibility
to
evaluate
and
verify
the
operation
of
any
non-IBM
product,
program,
or
service.
IBM
may
have
patents
or
pending
patent
applications
covering
subject
matter
described
in
this
document.
The
furnishing
of
this
document
does
not
give
you
any
license
to
these
patents.
You
can
send
license
inquiries,
in
writing,
to:
IBM
Director
of
Licensing
IBM
Corporation
North
Castle
Drive
Armonk,
NY
10504-1785
U.S.A.
For
license
inquiries
regarding
double-byte
(DBCS)
information,
contact
the
IBM
Intellectual
Property
Department
in
your
country
or
send
inquiries,
in
writing,
to:
IBM
World
Trade
Asia
Corporation
Licensing
2-31
Roppongi
3-chome,
Minato-ku
Tokyo
106,
Japan
IBM
may
use
or
distribute
any
of
the
information
you
supply
in
any
way
it
believes
appropriate
without
incurring
any
obligation
to
you.
The
following
paragraph
does
not
apply
to
the
United
Kingdom
or
any
other
country
where
such
provisions
are
inconsistent
with
local
law:
INTERNATIONAL
BUSINESS
MACHINES
CORPORATION
PROVIDES
THIS
PUBLICATION
AS
IS
WITHOUT
WARRANTY
OF
ANY
KIND,
EITHER
EXPRESS
OR
IMPLIED,
INCLUDING,
BUT
NOT
LIMITED
TO,
THE
IMPLIED
WARRANTIES
OR
CONDITIONS
OF
NON-INFRINGEMENT,
MERCHANTABILITY
OR
FITNESS
FOR
A
PARTICULAR
PURPOSE.
Some
states
do
not
allow
disclaimer
of
express
or
implied
warranties
in
certain
transactions,
therefore,
this
statement
may
not
apply
to
you.
This
information
could
include
technical
inaccuracies
or
typographical
errors.
Changes
are
periodically
made
to
the
information
herein;
these
changes
will
be
incorporated
in
new
editions
of
the
publication.
IBM
may
make
improvements
and/or
changes
in
the
product(s)
and/or
the
program(s)
described
in
this
publication
at
any
time
without
notice.
Copyright
IBM
Corp.
2000,
2003
39
Licensees
of
this
program
who
wish
to
have
information
about
it
for
the
purpose
of
enabling:
(i)
the
exchange
of
information
between
independently
created
programs
and
other
programs
(including
this
one)
and
(ii)
the
mutual
use
of
the
information
which
has
been
exchanged,
should
contact:
Lab
Director
IBM
Canada
Ltd.
Laboratory
8200
Warden
Avenue
Markham,
Ontario,
Canada
L6G
1C7
Such
information
may
be
available,
subject
to
appropriate
terms
and
conditions,
including
in
some
cases,
payment
of
a
fee.
The
licensed
program
described
in
this
document
and
all
licensed
material
available
for
it
are
provided
by
IBM
under
terms
of
the
IBM
Customer
Agreement,
IBM
International
Program
License
Agreement
or
any
equivalent
agreement
between
us.
Information
concerning
non-IBM
products
was
obtained
from
the
suppliers
of
those
products,
their
published
announcements
or
other
publicly
available
sources.
IBM
has
not
tested
those
products
and
cannot
confirm
the
accuracy
of
performance,
compatibility
or
any
other
claims
related
to
non-IBM
products.
Questions
on
the
capabilities
of
non-IBM
products
should
be
addressed
to
the
suppliers
of
those
products.
Any
references
in
this
information
to
non-IBM
Web
sites
are
provided
for
convenience
only
and
do
not
in
any
manner
serve
as
an
endorsement
of
those
Web
sites.
The
materials
at
those
Web
sites
are
not
part
of
the
materials
for
this
IBM
product
and
use
of
those
Web
sites
is
at
your
own
risk.
This
information
contains
examples
of
data
and
reports
used
in
daily
business
operations.
To
illustrate
them
as
completely
as
possible,
the
examples
may
include
the
names
of
individuals,
companies,
brands,
and
products.
All
of
these
names
are
fictitious
and
any
similarity
to
the
names
and
addresses
used
by
an
actual
business
enterprise
is
entirely
coincidental.
COPYRIGHT
LICENSE:
This
information
contains
sample
application
programs
in
source
language,
which
illustrates
programming
techniques
on
various
operating
platforms.
You
may
copy,
modify,
and
distribute
these
sample
programs
in
any
form
without
payment
to
IBM,
for
the
purposes
of
developing,
using,
marketing
or
distributing
application
programs
conforming
to
the
application
programming
interface
for
the
operating
platform
for
which
the
sample
programs
are
written.
These
examples
have
not
been
thoroughly
tested
under
all
conditions.
IBM,
therefore,
cannot
guarantee
or
imply
reliability,
serviceability,
or
function
of
these
programs.
You
may
copy,
modify,
and
distribute
these
sample
programs
in
any
form
without
payment
to
IBM
for
the
purposes
of
developing,
using,
marketing,
or
distributing
application
programs
conforming
to
IBMs
application
programming
interfaces.
Each
copy
or
any
portion
of
these
sample
programs
or
any
derivative
work,
must
include
a
copyright
notice
as
follows:
(C)
(your
company
name)
(year).
Portions
of
this
code
are
derived
from
IBM
Corp.
Sample
Programs.
(C)
Copyright
IBM
Corp.
2000,
2003.
All
rights
reserved.
40
Programming
interface
information
Programming
interface
information
is
intended
to
help
you
create
application
software
using
this
program.
General-use
programming
interfaces
allow
you
to
write
application
software
that
obtain
the
services
of
this
programs
tools.
However,
this
information
may
also
contain
diagnosis,
modification,
and
tuning
information.
Diagnosis,
modification
and
tuning
information
is
provided
to
help
you
debug
your
application
software.
Warning:
Do
not
use
this
diagnosis,
modification,
and
tuning
information
as
a
programming
interface
because
it
is
subject
to
change.
Trademarks
and
service
marks
The
following
terms
are
trademarks
or
registered
trademarks
of
International
Business
Machines
Corporation
in
the
United
States,
or
other
countries,
or
both:
v
AIX
v
CICS
v
Cloudscape
v
DB2
v
DB2
Extenders
v
DB2
Universal
Database
v
e-business
v
IBM
v
iSeries
v
OS/390
v
S/390
v
VisualAge
v
WebSphere
v
z/OS
Java
and
all
Java-based
trademarks
and
logos
are
trademarks
or
registered
trademarks
of
Sun
Microsystems,
Inc.
in
the
United
States
and
other
countries.
ActiveX,
Microsoft
,
Windows,
Windows
NT
,
and
the
Windows
logo
are
trademarks
or
registered
trademarks
of
Microsoft
Corporation
in
the
United
States,
or
other
countries,
or
both.
UNIX
is
a
registered
trademark
of
The
Open
Group.
Rational
is
a
trademark
of
International
Business
Machines
Corporation
and
Rational
Software
Corporation
,
in
the
United
States,
other
countries
or
both.
Other
company,
product,
and
service
names,
which
may
be
denoted
by
a
double
asterisk(**),
may
be
trademarks
or
service
marks
of
others.
Notices
41