Programming with Java IDL: Glossary of Java IDL Terms
- attribute (IDL)
- That part of an
IDL interface that is similar to a
public class field or C++ data member.
The
idltojava compiler
maps an OMG IDL attribute to accessor and modifier methods in the
Java programming language.
For example, an interface ball might include the
attribute color. The idltojava compiler
would generate a Java programming language method to get the color, and
unless the attribute is readonly, a method
to set the color.
CORBA attributes correspond closely to JavaBeans properties.
- client
- Any code which invokes an operation on a distributed object. A client
might itself be a CORBA object, or it might be a non-object-oriented
program,
but while invoking a method on a CORBA object, it is said to be acting as
client.
- client stub
- A Java programming language class generated
by idltojava
and used transparently
by the client ORB
during object invocation.
The remote object reference
held by the client points to the client stub.
This stub is specific to the IDL interface from which it
was generated, and it contains the information needed for
the client to invoke a method on the CORBA object that was
defined in the IDL interface.
- client tier
- The portion of a distributed application that requests services from
the server tier. Typically, the client tier is characterized by a
small local footprint, a graphical user
interface, and simplified development and maintenance efforts.
- Common Object Request Broker Architecture (CORBA)
- An OMG-specified architecture that is the
basis for the CORBA object model. The CORBA specification includes an
interface definition language (IDL), which is a language-independent way of
creating contracts between objects for implementation as distributed
applications.
See also: client tier,
service tier, data
store tier
- CORBA object
- An entity which (1) is defined by an OMG IDL interface,
and (2) for which an object reference is available.
Object is also the implicit common base type for
object references of IDL interfaces.
- data store tier
- The portion of a distributed application that manages access to persistent
data and its storage mechanisms, such as relational databases.
- distributed application
- A program designed to run on more than one computer, typically with
functionality separated into tiers such as client,
service, and
data store.
- distributed environment
- A network of one or more computers that use
CORBA objects.
Objects are installed on the various machines and can communicate with each other.
- Dynamic Invocation Interface (DII)
- An API that allows a client to make dynamic invocations on
remote CORBA objects.
It is used when at compile time a client does not have
knowledge about an object it wants to invoke.
Once an object is discovered, the client
program can obtain a definition of it, issue a
parameterized call to it, and receive a reply from it, all without having a
type-specific client stub
for the remote object.
- Dynamic Skeleton Interface (DSI)
- An API that provides a way to deliver requests from an ORB
to an object implementation when the type of the object
implementation is not known at compile time. DSI, which is the
server side analog to the client side DII,
makes it possible for the application programmer to inspect the parameters of
an incoming request to determine a target object and method.
- exception (IDL)
- An IDL construct that represents an exceptional condition that could
be returned in response to an invocation.
There are two categories of exceptions: (1) system exceptions,
which inherit from
org.omg.CORBA.SystemException
(which is a java.lang.RuntimeException),
and (2) user-defined exceptions, which inherit
from org.omg.CORBA.UserException
(which is a java.lang.Exception).
- factory object
- A CORBA object that is used to create new CORBA objects.
Factory objects are themselves usually created at server installation time.
- idltojava compiler
- A tool that takes an interface written in OMG IDL and produces
Java programming language interfaces and classes that represent the mapping from the
IDL interface to the Java programming language. The resulting
files are
.java files.
- implementation
- A concrete class that defines the behavior for all of
the operations and attributes of the IDL interface it supports.
A servant object is an instance of an
implementation. There may be many implementations of a single interface.
- initial naming context
- The NamingContext object returned by a call to the method
orb.resolve_initial_references("NameService"). It is an
object reference to the COS Naming Service
registered with the ORB and can be used to create other
NamingContext objects.
See also: naming context
- Interface Definition Language (IDL)
- The OMG-standard
language for defining the interfaces for all CORBA objects.
An IDL interface declares a set of
operations,
exceptions,
and attributes.
Each operation has a signature, which defines its name,
parameters, result and exceptions. OMG IDL
does not include implementations for operations;
rather, as its name indicates, it is simply a language
for defining interfaces.
The complete syntax and semantics for IDL are
available in chapter 3 of the OMG specification at
the OMG web site.
- Interface Repository (IFR)
- A service that contains
all the registered component interfaces, the methods they support, and
the parameters they require. The IFR stores, updates, and manages object
interface definitions. Programs may use the IFR APIs to access and
update this information. An IFR is not necessary for normal client/server
interactions.
- Internet InterORB Protocol (IIOP)
- The OMG-specified network protocol for communicating between ORBs.
Java IDL conforms to IIOP version 1.0.
- invocation
- The process of performing a method call on a CORBA object,
which can be done without knowledge of the object's
location on the network. Static invocation, which uses
a client stub for the invocation and a server skeleton for the
service being invoked, is used when the interface of the object is
known at compile time. If the interface is not known at compile
time, dynamic invocation must be used.
- Java IDL
- The classes, libraries, and tools that make it possible
to use CORBA objects from the Java programming
language. The main components of Java IDL are an ORB,
a naming service, and the
idltojava compiler.
The ORB and naming service are part of JDK1.2; the
idltojava compiler can be downloaded from the
Java Developer Connection (JDC) web site.
- name binding
- The association of a name with an
object reference. Name bindings are stored in a
naming context.
- namespace
- A collection of naming contexts that are grouped together.
- naming context
-
A CORBA object that supports the
NamingContext interface and
functions as a sort of directory which contains
(points to) other naming contexts and/or
simple names. Similar to a directory structure, where the last
item is a file and preceding items are directories, in a
naming context, the last item is an object reference name, and the
preceding items are naming contexts.
- naming service
-
A CORBA service that allows CORBA objects
to be named by means of binding a name to an object reference.
The name binding may be stored
in the naming service, and a client may supply the name
to obtain the desired object reference.
- object
-
A computational grouping of operations and data into a modular unit. An
object is defined by the interface it presents to others, its behavior when
operations on its interface are invoked, and its state.
- object implementation
- See implementation.
- Object Management Group (OMG)
-
An international organization with over 700 members
that establishes industry guidelines
and object management specifications in order to provide a common
framework for object-oriented application development. Its members include
platform vendors, object-oriented database vendors, software tool developers,
corporate developers, and software application vendors.
The OMG Common Object Request Broker Architecture
specifies the CORBA object model. See
www.omg.org for more information.
- object reference
- A construct containing the information needed to specify an object
within an ORB. An object reference is used in method invocations to locate a
CORBA object.
Object references are the CORBA object
equivalent to programming language-specific object pointers.
They may be obtained from a factory object or
from the Naming Service.
An object reference, which is opaque (its internal structure
is irrelevant to application developers), identifies the
same CORBA object each time it is used. It is possible, however,
for multiple object references to
refer to the same CORBA object.
- Object Request Broker (ORB)
-
The libraries, processes, and other infrastructure
in a distributed environment that enable
CORBA objects to communicate with each other. The
ORB connects objects requesting services to the objects providing them.
- operation (IDL)
- The construct in an
IDL interface
that maps to a Java programming language method.
For example, an interface ball might support the
operation bounce. Operations may take parameters, return
a result, or raise exceptions. IDL operations can be
oneway, in which case they cannot return results
(return values or out arguments) or raise exceptions.
- parameter (IDL)
- One or more objects the client passes to an IDL operation when it
invokes the operation.
Parameters may be declared as "in" (passed from client
to server), "out" (passed from server to client), or "inout" (passed from
client to server and then back from server to client).
- PIDL (Pseudo-IDL)
- The interface definition language for describing a CORBA
pseudo-object.
Each language mapping, including the mapping from IDL to the Java
programming language, describes how pseudo objects
are mapped to language-specific constructs. PIDL
mappings may or may not follow the rules that apply to
mapping regular CORBA objects.
- pragma
-
A directive to the idltojava compiler to perform certain
operations while compiling an IDL file. For example, the
pragma "javaPackage" directs the idltojava compiler
to put the Java programming language interfaces and classes it generates from the
IDL interface into the Java programming language package specified.
- pseudo-object
- An object similar to a CORBA object in that it is described
in IDL, but unlike a CORBA object, it cannot be passed around using its
object reference, nor can it be narrowed or stringified.
Examples of pseudo-objects include the Interface Repository and DII which,
although implemented as libraries, are more clearly described
in OMG specifications as pseudo-objects
with IDL interfaces. The IDL for pseudo-objects is called "PIDL" to indicate
that a pseudo-object is being defined.
- servant object
- An instance of an object implementation
for an IDL interface.
The servant object is registered
with the ORB so that the ORB knows where to send invocations.
It is the servant that performs the services requested when a CORBA
object's method is invoked.
- server
- A program that contains the implementations of one or more
IDL interfaces.
For example, a desktop publishing server
might implement a Document object type, a ParagraphTag
object type, and other related object types.
The server is required to
register each implementation (servant object)
with the ORB so that the ORB knows about the servant.
Servers are sometimes referred to as object servers.
- server skeleton
-
A public abstract class generated by the idltojava compiler
that provides the ORB with information it needs in dispatching
method invocations to the servant object(s).
A server skeleton, like a
client stub,
is specific to the IDL interface from which
it is generated. A server skeleton is the server side analog to a
client stub, and these two classes are used by ORBs
in static invocation.
- service tier
- The portion of a distributed
application that contains the business
logic and performs most of the computation.
The service tier is typically located
on a shared machine for optimum resource use.
- static invocation
- See invocation.
- stringified object reference
- An object reference that has been
converted to a string so that it may
be stored on disk in a text file (or stored in some other manner).
Such strings should be treated as opaque because they are ORB-implementation
independent. Standard object_to_string
and string_to_object methods on org.omg.CORBA.Object make
stringified references available to all CORBA Objects.
|