Java Standard Edition (SE)
Glossary
Glossary of Java IDL Terms
- adapter
activator
- An adapter activator is an object that the application
developer can associate with a POA. The ORB will invoke an operation on an adapter activator
when a request is received for a child POA that does not currently
exist. The adapter activator can then create the required POA on
demand.
- attribute
(IDL)
- An identifiable association between an object and a value. An
attribute A is made visible to clients as a pair of
operations: get_A and set_A. Readonly attributes
only generate a get operation.
Also, that part of an IDL interface that is
similar to a public class field or C++ data member. The idlj
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 idlj compiler would generate a Java
programming language method to get the color, and unless the
attribute is readonly
, a method to set the
color.
- 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 idlj 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.
The Java 2 Platform Standard Edition (J2SE) provides a CORBA Object
Request Broker (ORB) and two CORBA programming models that utilize
the Java CORBA ORB and Internet InterORB Protocol (IIOP). The two
programming models are the RMI programming model, or RMI-IIOP, and the IDL programming model,
or Java IDL. For more information
on these programming models, read CORBA
Technology and the Java Platform.
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.
- idlj 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. Prior to JDK 1.3,
the idlj compiler was known as the idltojava
compiler. The idlj compiler supports new CORBA-standard
features required for RMI-IIOP. The idlj compiler is
placed in the SDK's .bin directory by the
installer.
- 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. Beginning with
JDK 1.3, the IDL-to-Java language mapping is handled by the
idlj compiler, which supports new CORBA-standard features
required for RMI-IIOP. The idltojava
compiler can be
downloaded from the Java Developer Connection (JDC) web site.
- 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 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 CORBA/IIOP specification 2.3.1.
- 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
idlj
compiler. All are part of this release of
J2SE.
- 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. The two options for Naming
Services shipped with this version of Java SE are orbd, which is a daemon process containing a
Bootstrap Service, a Transient Naming Service, a Persistent Naming
Service, and a Server Manager, and tnameserv, a transient naming service.
- 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
adapter
- The ORB component which provides object reference, activation,
and state related services to an object implementation. There may
be different adapters provided for different kinds of
implementations. The POA is a particular type of
object adapter specified by OMG that can be used with multiple ORB
implementations with a minimum of rewriting needed to deal with
different vendors' implementations.
- object id
- An object id is a value that is used by the POA and by the user-supplied implementation to identify a particular
abstract CORBA object. Object Id values may be assigned and managed
by the POA, or they may be assigned and managed by the
implementation. Object Id values are hidden from clients,
encapsulated by references. Object Ids have no standard form; they
are managed by the POA as uninterpreted octet sequences.
- 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.
- operations interface
- A non abstract IDL interface is mapped to two public Java
interfaces: a signature
interface and an operations interface. The operations interface
has the same name as the IDL interface with the suffix
Operations appended to the end and is used in the
server-side mapping and as a mechanism for providing optimized
calls for collocated clients and servers.
- ORBD (Object Request Broker
Daemon)
- The orbd tool (Solaris, Linux, or Mac OS X or Windows) is a daemon process
containing a Bootstrap Service, a Transient Naming Service, a Persistent Naming Service,
and a Server Manager.
- 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).
- persistent object
- An object that can survive the process or thread that created
it. A persistent object exists until it is explicitly
deleted.
- 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.
- POA (Portable Object
Adapter)
- An object adapter is the mechanism that connects a request
using an object reference with the
proper code to service that request. The POA is a particular type
of object adapter specified by OMG that can be used with multiple
ORB implementations with a minimum of rewriting needed to deal with
different vendors' implementations.
The POA is also intended to allow persistent objects -- at
least, from the client's perspective. That is, as far as the client
is concerned, these objects are always alive, and maintain data
values stored in them, even though physically, the server may have
been restarted many times, or the implementation may be provided by
many different object
implementations.
- POA
Manager
- A POA manager is an object that encapsulates the processing
state of one or more POAs. Using operations on a
POA manager, the developer can cause requests for the associated
POAs to be queued or discarded. The developer can also use the POA
manager to deactivate the POAs.
- policy
- A policy is an object associated with a POA
by an application in order to specify a characteristic shared by
the objects implemented in that POA. This specification defines
policies controlling the POA's threading model as well as a variety
of other options related to the management of objects. Other
specifications may define other policies that affect how an
ORB processes requests on objects implemented in
the POA.
- Portable Interceptors
- Portable Interceptors are hooks into the ORB through which ORB
services can intercept the normal flow of execution of the ORB. For
more information, see
PortableInterceptor Package.
- pragma
- In J2SE v.1.2, 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. In J2SE v.1.3 and higher,
this functionality is supported via the -pkgPrefix command
line option to idlj.
- 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.
- RMI-IIOP
- Java RMI-IIOP is an Object
Request Broker and a compiler, rmic -iiop, that generates
IIOP stub and tie classes. With RMI-IIOP, developers can write
remote interfaces in the Java programming language and implement
them simply using Java technology and the Java RMI APIs. These
interfaces can be implemented in any other language that is
supported by an OMG mapping and a vendor supplied ORB for that
language. Similarly, clients can be written in other languages
using IDL derived from the remote Java technology-based interfaces.
Using RMI-IIOP, objects can be passed both by reference and by
value over IIOP.
- servant
- A servant is a programming language object or entity that
implements requests on one or more objects. Servants generally
exist within the context of a server process. Requests made on an
object's references are mediated by the ORB and
transformed into invocations on a
particular servant. In the course of an object's lifetime it may be
associated with (that is, requests on its references will be
targeted at) multiple servants.
- servant
manager
- A servant manager is an object that the application developer
can associate with a POA. The ORB will invoke operations on servant managers to
activate servants on demand, and to deactivate servants. Servant
managers are responsible for managing the association of an object
(as characterized by its Object Id value) with a particular
servant, and for determining whether an object exists or not. There
are two kinds of servant managers, called ServantActivator
and ServantLocator; the type used in a particular situation depends
on policies in the POA.
- 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 idlj 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.
- servertool
- The Java IDL Server Tool, servertool (Solaris, Linux, or Mac OS X or Windows) provides the
ease-of-use interface for the application programmers to register,
unregister, startup, and shutdown a server.
- 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.
- signature interface
- A non-abstract IDL interface is mapped to two public Java
interfaces: a signature interface and an operations interface. The signature
interface, which extends IDLEntity, has the same name as
the IDL interface name and is used as the signature type in method
declarations when interfaces of the specified type are used in
other interfaces.
- skeleton
- The object-interface-specific ORB component
which assists an object adapter in
passing requests to particular methods.
- 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.
- stub
- A local procedure corresponding to a single operation that
invokes that operation when called.
- tnameserv
- The CORBA COS (Common Object Services) Naming Service provides
a tree-like directory for object references much like a filesystem
provides a directory structure for files. The Transient Naming
Service provided with Java IDL, tnameserv> (Solaris, Linux, or Mac OS X or Windows), is a simple
implementation of the COS Naming Service specification. Object references are stored in the
namespace by name and each object reference-name pair is called a
name binding. Name bindings may be organized under naming contexts.
Naming contexts are themselves name bindings and serve the same
organizational function as a file system subdirectory. All bindings
are stored under the initial naming context. The initial naming
context is the only persistent binding in the namespace; the rest
of the namespace is lost if the transient naming service process
halts and restarts.
- transient
object
- An object whose existence is limited by the lifetime of the
process or thread that created it.
Content
License.
All information of this service is derived from the free sources and is provided solely in the form of quotations.
This service provides information and interfaces solely for the familiarization (not ownership) and under the "as is" condition.
Copyright 2016 © ELTASK.COM. All rights reserved.
Site is optimized for mobile devices.
Downloads: 274 / 159135588. Delta: 0.00588 с