Chapter 5 Client Design

235

Boundary checking can help prevent service exceptions. For example, a client

of an order tracking service might first check that an order identifier is a five digit

integer, or that its value falls within a certain range. While the JAX RPC API

ensures that types are correct, the application developer is responsible for check 

ing boundary limitations. 

Clients in a J2EE environment that present HTML content can use JavaScript

to validate boundaries before sending requests to a service. Clients using an

HTML interface should ensure that types for entered values are correct, since

HTML parameters are all treated as 

String

 objects.

E

Do boundary checking and other validations on the client side so that Web ser 

vice calls and round trips to the server are kept to a minimum.

5.4

General Considerations

There are some general considerations that Web service client developers might

want to keep in mind. In particular, developers need to be aware of the issues regard 

ing conversational state. Also included in this section are some guidelines for

improving or enhancing the user experience, and a short discussion of server side

design considerations. Last, there is an explanation of how to package client appli 

cations. 

5.4.1 Managing Conversational State

Clients should view Web services as stateless and should assume that a service end 

point retains no knowledge of previous client interactions. However, some use cases

may require a client to make a sequence of calls to a service to accomplish a given

operation. 

It is best if the client application maintains state when circumstances require

this. The client may manipulate this retained state when not online. There are

ways for a client to identify itself across multiple calls to a service and manage its

state to keep it in sync with state on the server.

5.4.1.1

Coordinating State with a Service Endpoint

There are certain situations where the client may want to have its conversational

state managed by the service endpoint. A client application, for example, may have

only minimal processing capabilities and insufficient memory resources to ade