104

Publishing a Web Service

When a registry is used, we have seen that the service provider publishes the

Web service description on a registry and clients discover and bind to the Web

service to use its services. In general, a client must perform three steps to use a

Web service:

1. The client must determine how to access the service's methods, such as deter 

mining the service method parameters, return values, and so forth. This is re 

ferred to as discovering the service definition interface.

2. The client must locate the actual Web service; that is, find the service's ad 

dress. This is referred to as discovering the service implementation.

3. The client must be bound to the service's specific location, and this may occur

on one of three occasions:

I

When the client is developed (called static binding)

I

When the client is deployed (also called static binding)

I

During runtime (called dynamic binding)

These three steps may produce three scenarios. The particular scenario

depends on when the binding occurs and whether the client is implemented solely

for a specific service or is a generic client. The following paragraphs describe

these scenarios. (See Table 3.2 for a summary.) They also note important points

you should consider when designing and implementing a Web service. (Chapter 5

considers these scenarios from the point of view of a client.) 

  Scenario 1: The Web service has an agreement with its partners and publishes 

its WSDL description and referenced XML schemas at a well known, speci 

fied location. It expects its client developers to know this location. When this 

is the case, the client is implemented with the service's interface in mind. 

When it is built, the client is already designed to look up the service interface 

directly rather than using a registry to find the service. 

  Scenario 2: Similar to scenario 1, the Web service publishes its WSDL descrip 

tion and XML schemas at a well known location, and it expects its partners to 

either know this location or be able to discover it easily. Or, when the partner 

is built, it can use a tool to dynamically discover and then include either the ser 

vice's specific implementation or the service's interface definition, along with 

its specific implementation. In this case, binding is static because the partner is