Servant and objects - relation

Question

I read a lot about servant and objects used in technologies such as ICE or Corba. There are a lot of resources where I can read something like this :

One servant can handle multiple objects (for resource saving). One object can be handled by multiple servants (for reliability).

Could somebody tell me a real life example for this two statements ?

Answer 1

If i am not mistaken, this term was coined by Douglas Schmidt in his paper describing Common Object Request Architecture.

Here is a direct quote of few definitions:

• Note: see picture below for clarity

Object -- This is a CORBA programming entity that consists of an identity, an interface, and an implementation, which is known as a Servant.

Servant -- This is an implementation programming language entity that defines the operations that support a CORBA IDL interface. Servants can be written in a variety of languages, including C, C++, Java, Smalltalk, and Ada.

CORBA IDL stubs and skeletons -- CORBA IDL stubs and skeletons serve as the ``glue'' between the client and server applications, respectively, and the ORB

ORB Interface -- An ORB is a logical entity that may be implemented in various ways (such as one or more processes or a set of libraries). To decouple applications from implementation details, the CORBA specification defines an abstract interface for an ORB. This interface provides various helper functions such as converting object references to strings and vice versa, and creating argument lists for requests made through the dynamic invocation interface described below.

CORBA

The Common Object Request Broker Architecture (CORBA) is a standard defined by the Object Management Group (OMG) designed to facilitate the communication of systems that are deployed on diverse platforms. CORBA enables collaboration between systems on different operating systems, programming languages, and computing hardware

So, there are clients, server, client and server proxies, and ORB core. Client and server use proxies to communicate via ORB core, which provides a mechanism for transparently communicating client requests to target object implementations. From client perspective, this makes calls on remote objects look like the objects are in local address space and therefore simplifies design of clients in distributed environment.

Given all the above, Servant is an implementation which is an invocation target for remote client calls, and is abstracting remote objects which are actual targets.

As for your question, one servant can handle calls to multiple distributed objects which are encapsulated by the Servant. Note that the client doesn't access these objects directly but goes via Servant.

Answer 2

One servant for multiple objects is for example a bank, each bank account is an object but in this case you don't want to have a servant in memory for each bank account, so you have one servant for all bank accounts.

One object handled by multiple servants is for things like load balancing and fault tolerance. The client doesn't know which exact one it is executed on.