BEA WebLogic Enterprise Release 5.1 Documentation: Home Page

	WebLogic Enterprise Doc Home
	What's New
	Installation Guide
	Getting Started
	Product Overview
	Interoperability

	T-Engine CORBA Programming Administration Reference Sample Applications Messages API Javadoc
	T-Engine J2EE Programming Administration Reference Sample Applications Messages API Javadoc

	J-Engine J2EE Documentation

	WebLogic Enterprise Connectivity Documentation

	Tuxedo Documentation

	Jolt Documentation

BEA WebLogic Enterprise Release 5.1

Corporate Info | News | Solutions | Products | Partners | Services | Events | Download | How To Buy

Glossary

Click a letter in the glossary index. Or use the Page Down key, the Page Up key, the arrow keys, or the scroll bar to navigate. Please contact us if you encounter a relevant term that was not defined in this glossary.

- A -

Access Control List (ACL): A list of which entities are allowed to invoke which objects and methods.
Access Decision object: The object within the WebLogic Enterprise security infrastructure that enforces the checking of authorized access before a request to the target object is delivered.
ACID properties: The essential characteristics of transaction processing systems:; Atomicity: All changes that a transaction makes to a database are made permanent; otherwise, all changes are rolled back.; Consistency: A successful transaction transforms a database from a previous valid state to a new valid state.; Isolation: Changes that a transaction makes to a database are not visible to other operations until the transaction completes its work.; Durability: Changes that a transaction makes to a database survive future system or media failures.
activation: The process of preparing an object for execution. When using EJBs, the operation where a container reloads the state of a bean from persistent storage and makes the bean available again.
activation policy: The policy that determines the in-memory activation duration for a CORBA object.; See also activation, CORBA object, and policy.
Active object: A running instance of an object interface.; See also Active Object Map, CORBA object, enterprise bean, object ID (OID), object reference, Portable Object Adapter (POA), servant, and WebLogic Enterprise client application.
Active Object Map: A table maintained by a POA and the TP Framework, or the EJB container that maps the association of object IDs to servants.; See also object ID (OID), Portable Object Adapter (POA), and servant.
ActiveX: See Component Object Model (COM).
AdminAPI: The combination of the management information base (MIB) and programmatic interfaces for accessing and manipulating system and run-time information.
API: See application programming interface (API).
applet: An application written in Java to run within a Web browser that is compatible with Java.
application: In the WebLogic Enterprise system, a single computer program designed to do a certain type of work.; See also BEA WebLogic Enterprise system.
Application Assembler: A domain expert who composes applications that use EJBs. The application assembler works with the deployment descriptor and client-view contract of the EJB. The application assembler does not have any knowledge of the implementation of an EJB except the interfaces of the EJB that define the contract between the client and the server.
application code: Code that is written by the user, as opposed to system code that is provided by BEA Systems, Inc.
application-controlled deactivation: A feature of the WebLogic Enterprise software that you can use with the process activation policy to keep an object active in memory until the application explicitly deactivates the object by invoking the TP::deactivateEnable() operation on that object.
application programming interface (API): The verbs and environment that exist at the application level to support a particular system software product. A set of well-defined programming interfaces (that is, entry points, calling parameters, and return values) by which one software program uses the services of another.
asymmetric algorithm: An encryption algorithm that has two keys: a public key and a private key. The public key can be distributed openly while the private key is kept secret. Asymmetric algorithms may be capable of a number of operations, including encryption, digital signatures, and key agreements.
asymmetric outbound IIOP: See outbound IIOP.
ATMI: Application to Transaction Monitor Interface. The application interface to the BEA Tuxedo system that includes transaction routines, message handling routines, service interface routines, and buffer management routines.
attribute: An identifiable association between an object and a value.; When using OMG IDL, that part of an OMG IDL interface that is similar to a public class field or data member. The compiler maps an OMG IDL attribute to accessor and modifier methods in either the C++ or Java programming language. For example, an interface ball might include the attribute color . The idltojava compiler would generate a C++ or Java programming language method to get the color , and, unless the attribute is read-only, would generate a method to set the color . CORBA attributes correspond closely to JavaBeans properties.; See also CORBA object and object.
authentication: The process of determining whether someone or something is, in fact, who or what it is declared to be.
authorization: The granting of authority, which includes granting access based on access rights.

- B -

BEA ActiveX Client: The component of the WebLogic Enterprise software that provides interoperability between a WebLogic Enterpise domain and the ActiveX object system. The ActiveX Client translates into ActiveX methods the interfaces of CORBA objects that are located in the WebLogic Enterprise domain.; The ActiveX Client has two components: the BEA Application Builder and the Object Bridge.; See also ActiveX, BEA Application Builder, Object Bridge, and WebLogic Enterprise domain.
BEA Administration Console: A Java applet that you can download into your Internet browser and use to remotely administer WebLogic Enterprise client and server applications and BEA Tuxedo systems. The BEA Administration Console offers a convenient graphical user interface (GUI) for performing your system administration tasks.; See also BEA Tuxedo system, WebLogic Enterprise client application, and WebLogic Enterprise server application.
BEA Application Builder: The component of the WebLogic Enterprise software that creates ActiveX bindings for CORBA interfaces.; See also ActiveX, BEA WebLogic Enterprise software, binding, and CORBA.
Bean-managed persistence: For entity beans, using handwritten SQL (or some other handwritten persistence mechanism) within the bean to manage the storage and retrieval of its state information.
Bean Provider: An application programmer who produces enterprise bean classes, remote and home interfaces, and descriptor files, and package them in an EJB .jar file.
BEA Tuxedo application: One or more BEA Tuxedo domains cooperating to support a single business function.; See also BEA Tuxedo domain.
BEA Tuxedo domain: A collection of BEA Tuxedo servers, services, interfaces, machines, and associated resource managers defined by a single UBBCONFIG (ASCII version) or TUXCONFIG (binary version) configuration file.; See also TUXCONFIG file, UBBCONFIG file, and WebLogic Enterprise domain.
BEA Tuxedo system: The BEA Tuxedo software as the customer receives it from BEA Systems, Inc.
BEA WebLogic Enterprise software: The BEA WebLogic Enterprise product as the customer receives it from BEA Systems, Inc.; See also BEA WebLogic Enterprise system.
BEA WebLogic Enterprise system: The BEA WebLogic Enterprise software and the hardware on which the WebLogic Enterprise software is running.; See also BEA WebLogic Enterprise software.
BEA Wrapper Callbacks API: An application programming interface designed specifically to simplify the implementation of callback objects for WebLogic Enterprise CORBA joint client/server applications. The API provides specific methods for defining, starting, stopping, and destroying callbacks objects.; See also application programming interface (API), Callbacks Wrapper object, CORBA callback object, and joint client/server application.
bidirectional outbound IIOP: See outbound IIOP.
bind: The process of associating a name with an application object or a naming context object. Also used to describe the process of connecting a client application to an application object.
binding: In the BEA ActiveX Client, the association of the interface of a CORBA object to another object system, such as an ActiveX object system.; See also ActiveX, BEA ActiveX Client, CORBA object, and object.
Bootstrap environmental object: The object that brings a CORBA application into the WebLogic Enterprise domain and provides initial object references to that application. Every CORBA client or server application that interacts with a WebLogic Enterprise domain needs a Bootstrap environmental object.; See also environmental object, object, object reference, and WebLogic Enterprise domain.
bootstrapping: The process of setting up an application to interact with CORBA objects that are located within the WebLogic Enterprise domain.; See also Bootstrap environmental object, CORBA object, and WebLogic Enterprise domain.
business object: An application-level component that can be used in combinations that may not be defined ahead of time. A business object is independent of any single application and represents a recognizable, everyday-life entity, such as a document processor. A business object is a self-contained deliverable that has a user interface and a state, and that can cooperate with other separately developed business objects to perform a desired task.; See also object.

- C -

callback method: A method that is implemented by application code and that is invoked by system code when needed to perform a specific function. Callback methods are never intended to be invoked directly by application code.; See also application code and metadata interface.
Callbacks Wrapper object: An object implemented to support callbacks on CORBA joint client/server applications using the BEA Wrapper Callbacks API.; See also BEA Wrapper Callbacks API, callback method, CORBA callback object, joint client/server application, and object.
certificate: A digital statement that associates a particular public key with a name or other attributes. The statement is digitally signed by a certificate authority (CA). By trusting that authority to sign only true statements, you can trust that the public key belongs to the person named in the certificate.; See also Certificate Authority (CA).
Certificate Authority (CA): A well-known and trusted entity that issues public key certificates. A certificate authority attests to a user's real-world identity, somewhat like a Notary Public.; See also certificate.
Certificate-based Authentication: A method that provides confident identification of a client by a server through the use of digital certificates. Certificate-based authentication is generally preferred over password-based authentication because it is based on what the user has (the private key) as well as what the user knows (the password that protects the private key).; See also authentication and certificate.
cipher suite: An SSL encryption method that includes the key exchange algorithm, the symmetric encryption algorithm, and the secure hash algorithm used to protect the integrity of the communication.; See also Secure Sockets Layer (SSL).
class: In Java, a type that defines the implementation of a particular kind of object. A class definition defines instances and class variables and methods, and specifies the interfaces and class implementations and the immediate superclass of the class. If the superclass is not explicitly specified, the superclass will implicitly be Object.; See also IDL interface, instance, Java, Java interface, metadata interface, and object.
client: Any code that invokes an operation on a distributed object.
client application: See WebLogic Enterprise client application.
Client Data Caching design pattern: The design pattern that provides increased performance for client applications by caching server application data on the machine on which the client application resides, thereby avoiding repeated remote calls to retrieve data.; See also design pattern.
CMP: See container-managed persistence (CMP).
COM: See Component Object Model (COM).
Common Object Request Broker Architecture: See CORBA.
Component Object Model (COM): A collection of services that let software components interoperate in a networked environment.; See also COM view, CORBA, and object.
COM view: A representation of an object that conforms to the Component Object Model (COM) standards, including implementations of all necessary interfaces.; See also Component Object Model (COM), interface, and object.
constructor: A pseudo-method that creates an object. In Java, constructors are instance methods with the same name as their class. Java constructors are invoked using the new keyword.; See also class, instance, Java, metadata interface, and object.
container: A system that functions as the infrastructure for EJBs. Multiple EJBs can be deployed in the same container. The container is responsible for managing transactions, the state of an EJB, resource pooling, deployment, administration, naming, and other object services.
container-managed persistence (CMP): For entity beans, allowing the container to take care of managing the state information of the entity bean.
CORBA: Common Object Request Broker Architecture. A multivendor standard published by the Object Management Group for distributed object-oriented computing.; See also Component Object Model (COM).
CORBA callback object: A CORBA object supplied as a parameter in a client application's invocation on a target object. The target object can make invocations on the callback object either during the execution of the target object or at some later time (even after the invocation on the target object has been completed). A callback object might be located inside or outside a WebLogic Enterprise domain.; See also client application, CORBA object, RMI client stub, and WebLogic Enterprise domain.
CORBA client stub: When using CORBA objects, a file created by the IDL compiler when you compile an application's OMG IDL statements. The client stub contains code that is generated during the client application build process. The client stub maps OMG IDL operation definitions for an object type to the methods in the server application that the WebLogic Enterprise domain calls when it invokes a request. The code is used to send the request to the CORBA server application.; When using OMG IDL, a C++ or Java programming language class created by the compiler 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 contains the information needed for the client to invoke a method on the CORBA object defined in the IDL interface.; See also metadata interface, OMG IDL, skeleton, RMI client stub, and WebLogic Enterprise domain.
CORBAfacilities: The adopted OMG Common Facilities. Common Facilities provide horizontal end-user-oriented frameworks that are applicable to most applications, and are defined in OMG IDL.; See also OMG IDL.
CORBA interface: A set of operations and attributes. A CORBA interface is defined by using OMG IDL statements to create an interface definition. The definition contains operations and attributes that can be used to manipulate an object.; See also attribute, interface, object, OMG IDL, and operation.
CORBA object: An entity that complies with the CORBA standard upon which operations are performed. An object is defined by its interface.; See also interface, object, and operation.
CORBA ORB: Any Object Request Broker (ORB) that complies with the CORBA standard. A CORBA ORB is a communications intermediary between client and server applications that typically are distributed across a network. The WebLogic Enterprise ORB is a CORBA ORB.; See also CORBA.
CORBAservices: A set of system services for objects that were developed for the programmer. These services, defined in OMG IDL by the OMG, can be used to create objects, control access to objects, track objects and object references, and control the relationship between types of objects. Programmers can call object service functions instead of writing and calling their own private object service functions.; See also CORBA object, CORBAservices Life Cycle Service, CORBAservices Naming Service, CORBAservices Object Transaction Service (OTS), CORBAservices Security Service, object, object reference, and OMG IDL.
CORBAservices Life Cycle Service: The CORBAservice that defines conventions for creating, deleting, copying, and moving objects.; See also CORBAservices and object.
CORBAservices Naming Service: The CORBAservice that provides the ability to associate a name to an object relative to a naming context.
CORBAservices Object Transaction Service (OTS): The CORBAservice that provides transaction semantics to ensure the integrity of data in the system.; See also CORBAservices, Java Transaction API (JTA), and Java Transaction Service (JTS).
CORBAservices Security Service: The CORBAservice that defines identification and authentication of principals, authorization and access control, security auditing, security of communication between objects, nonrepudiation, and administration of security information.; See also authentication, authorization, Callbacks Wrapper object, and object.
core class: A public class (or interface) that is a standard member of the Java platform. The intent is that the Java core classes, at a minimum, are available on all operating systems on which the Java platform runs.; See also class, interface, and Java.
credentials: Information that describes the security attributes (identity and/or privileges) of a user or other principal. Credentials are claimed through authentication or delegation and are used by access control.; See also authentication.
Credentials object: The object that holds the security attributes of a principal. These security attributes include the principal's authenticated or unauthenticated identities. The Credentials object also contains information for establishing security associations. The Credentials object provides methods to obtain the security attributes of the principals it represents.; See also attribute, metadata interface, and object.
Current: A special type of ORB object that is used to communicate between a user application and a specialized built-in service.; See also CORBA ORB, object, SecurityCurrent, and TransactionCurrent.

- D -

decryption private key: An algorithm that reverses the work of the encryption algorithm.
deployable JAR file: A JAR file that contains container-specific classes and interfaces that are used by the container to manage EJBs at run time. A deployable JAR file also contains the context of the ejb.jar .
Deployer: A person who has expertise at a specific operational environment (for example, mapping security roles to user groups and accounts) and who is responsible for the deployment of EJBs. The Deployer uses tools supplied by BEA Systems, Inc. to perform deployment tasks.
deployment descriptor: An XML file that specifies two broad categories of information about an EJB: the structure of the EJB and its external dependencies, and how the EJB is incorporated into a larger application deployment unit. The types of information specified in an EJB's deployment descriptor include (but is not limited to): the bean's name, its class, its home and remote interfaces, the bean's type (entity versus session), persistence information, security roles, and transaction attributes.
design pattern: A document that encapsulates, in a structured format, solutions to design problems. Design patterns are guides to good design practices.; See also Client Data Caching design pattern and Process-Entity design pattern.
desktop client: A client application that operates on a Microsoft desktop platform, such as Windows NT or Windows 95. Desktop client applications use the Component Object Model (COM) and communicate with the WebLogic Enterprise domain by using the ActiveX Client to translate between COM and CORBA.; See also BEA ActiveX Client, Component Object Model (COM), CORBA, and WebLogic Enterprise domain.
digital signature: An electronic signature that can be used to authenticate the identity of the sender of a message. A digital signature can also be used to ensure that the original content of a message that has been sent is unchanged.
DII: See Dynamic Invocation Interface (DII).
Distinguished Name (DN): A distinguished name (DN) is an entry in the Directory Information Tree (DIT) that uniquely identifies an object in an X.500 directory.; See also object.
distributed object: An object that can live anywhere on a network. Distributed objects are packaged as independent pieces of code that can be accessed by remote clients via method invocations. The language and compiler used to create distributed objects are totally transparent to the clients. Clients do not need to know where the distributed object resides or what operating system executes on it.
domain: See BEA Tuxedo domain and WebLogic Enterprise domain.
Domain Configuration (DMCONFIG ) File: The file that describes the relationship between the local domain (the domain in which the DMCONFIG file resides) and remote domains (any other domains). There is one DMCONFIG file per domain. The DMCONFIG file contains domain information for BEA Tuxedo domains and for WebLogic Enterprise domains.; See also BEA Tuxedo domain and WebLogic Enterprise domain.
DSI: See Dynamic Skeleton Interface (DSI).
dual-paired connections outbound IIOP: See outbound IIOP.
Dynamic Invocation Interface (DII): An API that allows a CORBA client to either perform invocations on an object whose signature may be unknown at compile time, or a deferred synchronous invocation. If an object's signature is unknown, the client locates the object and uses the Interface Repository to obtain information about the object's signature and constructs an invocation with the proper parameters. The client can then issue the invocation and receive the response. DII is distinguished from the static invocation interface in which a client performs a synchronous invocation using client stubs. DII also allows a client to issue a request and to not block until the request is completed. The client checks for a response at a later time.; See also Dynamic Skeleton Interface (DSI).
Dynamic Skeleton Interface (DSI): An API that provides a way to deliver requests from an ORB to an object implementation. DSI is used at compile time when the ORB has no knowledge of the object implementation. As the server-side analog to the client-side DII, DSI lets the application programmer examine the parameters of an incoming request to determine a target object and method.; See also Dynamic Invocation Interface (DII).

- E -

EJB cache: Stores the state of Stateful Session beans and Entity beans in server process memory instead of passivating them.
EJB home interface: An EJB component interface that allows clients to look up and/or create EJBs.
EJB JAR file: Used by EJB tools for packaging EJBs with their declarative information. The EJB JAR file is intended to be processed by application assembly and deployment tools.
EJB remote interface: Defines the business methods callable by a client. The remote interface extends the javax.ejb.EJBobject interface.
EJB roles: The EJB specification defines six distinct roles in the application development and deployment cycle of an EJB. Note that all the EJB roles may be performed by one person. BEA Systems, Inc. is an EJB Server and an EJB container provider.; See also Application Assembler and Deployer.
encryption: The conversion of data into a form, called a cipher, that cannot be easily understood by unauthorized people.
encryption key pair: An encryption key pair consists of the public key used to encrypt information and a private key used to decipher the information.
enterprise bean: A software component that describes the general bean implementation. An enterprise bean can be either a session bean or an entity bean.
Enterprise JavaBeans (EJB): An API specification for building scalable, distributed, component-based, multitiered applications. EJBs leverage and extend the JavaBeans component model to provide a rich, object-oriented transactional environment for developers creating enterprise applications.
entity bean: A long-lived bean that represents data in an underlying data store and can be shared by multiple clients.
environmental object: Any support object that provides independence from the underlying environment (for example, independence from the operating system). The Bootstrap object is an environmental object.; See also Bootstrap environmental object and object.
exception: An event that occurs during program execution that prevents the program from continuing normally (usually an error). C++ and Java support exceptions with the try , catch , and throw keywords. There are two categories of exceptions: system and user-defined.; In Java, system exceptions inherit from org.omg.CORBA.SystemException (which is a java.lang.RuntimeException ); user-defined exceptions inherit from org.omg.CORBA.UserException (which is a java.lang.Exception ).; In C++, system exceptions inherit from CORBA::System_Exception and user-defined exceptions inherit from CORBA::User_Exception .

- F -

factory: Any distributed CORBA object that returns an object reference to other distributed CORBA objects. A factory is located in the server application.; See also CORBA object, object reference, and WebLogic Enterprise server application.
factory-based routing: A feature of the WebLogic Enterprise software that permits the routing of requests on a CORBA object reference to a specific server group based on criteria supplied at the time the object reference is created by a factory.; See also BEA WebLogic Enterprise software, factory, and object reference.
factory finder: A CORBA object that locates the factories that an application needs. Both client applications and server applications can use a factory finder. A factory finder object provides an implementation of the CORBAservices COSLifeCycle.FactoryFinder interface, as well as the BEA Tobj.FactoryFinder interface.; See also factory, local factory, object, WebLogic Enterprise client application, and WebLogic Enterprise server application.
factory_finder.ini file: The FactoryFinder configuration file for domains. This file is parsed by the TMFFNAME service when it is started as a Master NameManager. The file contains information used by NameManagers to control the import and the export of object references for factory objects with other domains.; See also domain, factory, and object reference.
failover: A seamless transfer of message traffic to a lower priority circuit on the occasion of the failure of a higher priority circuit.
foreign client: See WebLogic Enterprise foreign client application.

- G -

garbage collection: The automatic detection and freeing of memory that is no longer in use. The Java run-time system performs garbage collection so that programmers never explicitly free objects.
General Inter-ORB Protocol (GIOP): A standard for communication between independent CORBA Object Request Broker (ORB) implementations. GIOP was developed by the Object Management Group (OMG). GIOP is an abstract protocol that forms the basis for specific protocols that map the GIOP standard to individual transport layers. For example, IIOP maps the GIOP standard to the TCP/IP transport layer.; See also CORBA ORB and IIOP.
GIOP: See General Inter-ORB Protocol (GIOP).
global transaction: A transaction that can execute in more than one server, accessing data from more than one resource manager. A global transaction may be composed of several local transactions, each accessing a single resource manager.; See also resource manager.

- H -

home interface: See EJB home interface.

- I -

ICF: See Implementation Configuration File (ICF).
IDL: See OMG IDL.
idl compiler: A tool that takes an OMG IDL interface and produces C++ programming language interfaces and classes that represent the mapping from the IDL interface to the C++ programming language.; See also OMG IDL.
IDL interface: A declaration in OMG IDL of an interface to a CORBA object. The interface declaration contains IDL operations and attributes. The OMG IDL interface declaration is used to generate stubs and skeletons for WebLogic Enterprise CORBA objects.; See also CORBA object, interface, OMG IDL, and skeleton.
IDL parameter: 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).
idltojava compiler: A tool that takes an OMG IDL interface 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.; See also OMG IDL.
IIOP: Internet Inter-ORB Protocol. A protocol specified by the Object Management Group (OMG). The IIOP enables two or more Object Request Brokers (ORBs) to cooperate to deliver requests to an object.; See also CORBA ORB and object.
IIOP Handler (ISH): A WebLogic Enterprise system process that handles all IIOP communication between a remote application and target WebLogic Enterprise objects.; See also Jolt Server Handler (JSH) and Workstation handler (WSH).
IIOP Listener (ISL): A WebLogic Enterprise system process that listens for incoming IIOP connections from remote applications. After a connection is established, the Listener hands off the connection to the IIOP Handler.; See also Jolt Server Listener (JSL) and Workstation listener (WSL).
IIOP Listener/Handler: The feature of the WebLogic Enterprise software that enables client applications to communicate with the WebLogic Enterprise domain, and the reverse. The IIOP Listener/Handler receives a request from a client application via the IIOP protocol, and then sends that request to the appropriate server application within the WebLogic Enterprise domain. It also receives a request from a server application in the WebLogic Enterprise domain and sends the request to a server outside the domain.; See also BEA WebLogic Enterprise software, IIOP, WebLogic Enterprise client application, WebLogic Enterprise domain, and WebLogic Enterprise server application.
implementation: A class that defines the behavior for all operations and attributes of the supported interface. There may be many implementations of a single interface.
implementation code: The method code that you write that satisfies a client application's request on a specific object. The interface defines the operation and is implemented in the method.; See also interface, metadata interface, and object.
Implementation Configuration File (ICF): A file that describes the implementation attributes of WebLogic Enterprise C++ server applications. The ICF file is input to the IDL compiler when generating skeletons for WebLogic Enterprise C++ server applications.; See also skeleton and WebLogic Enterprise server application.
implementation file: The file that contains, among other data, method declarations for each operation defined in your OMG IDL statements. You need to implement the method with your business logic. When you build the server application, you provide this implementation file to the WebLogic Enterprise build procedure.; See also implementation code, metadata interface, OMG IDL, operation, and WebLogic Enterprise server application.
initialContext: An object used to access a service provider using JNDI, which creates a context for the provider.; See also Java Naming and Directory Interface (JNDI).
initial naming context: When using CORBA objects, the NamingContext object returned by a call to the method orb.resolve_initial_references ("NameService "). It is an object reference to the CosNaming Service registered with the ORB. The initial naming context can be used to create other NamingContext objects.; See also naming context.
instance: A particular realization of an abstraction or template, such as a class of objects or a computer process.
instantiate: To create an instance by defining one particular variation of an object within a class, giving it a name and locating the object in some physical place.
interface: See IDL interface and Java interface.
Interface Repository: An online database that contains the definitions of the interfaces that determine the CORBA contracts between client and server applications.; See also CORBA, IDL interface, and Java interface.
Interoperable Object Reference (IOR): The entity that associates a collection of tagged profiles with object references. An ORB must create an IOR (from an object reference) whenever an object reference is passed across ORBs.; See also CORBA ORB and object reference.
invocation: The process of performing a method call on a distributed object, with or without knowledge of the object's location on the network. CORBA 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. CORBA Dynamic invocation must be used if the interface is not known at compile time.; See also CORBA callback object and skeleton.
invocation access policy: The security policy that controls whether a client application may invoke a method on the target object as specified in the request.; See also metadata interface and policy.

- J -

J-Engine: Provides the front-end EJB container in the WebLogic Enterprise product. The EJB container interacts with the Web or browser users. The J-Engine provides page serving and Web business logic as well as a J2EE implementation that includes servlets, Java Server Pages (JSP), Java Messaging Service (JMS), and Java Naming and Directory Interface (JNDI). Clustering, the Wireless Application Protocol (WAP), and Extensible Markup Language (XML) functionality is also provided.; See also T-Engine.
JAR files (.jar): Java ARchive files. A file format used for aggregating many files into one file.; See also Java.
Java: An object-oriented programming language developed by Sun Microsystems, Inc. A "write once, run anywhere" programming language.
Java 2 Enterprise Edition (J2EE): An environment for developing and deploying enterprise applications. The J2EE platform consists of a set of services, APIs, and protocols that provide the functionality for developing multitiered, Web-based applications.
Java Database Connectivity (JDBC): An industry standard for database-independent connectivity between Java and a wide range of databases. The JDBC provides a call-level API for SQL-based database access.; See also Java.
Java Development Kit (JDK): A software development environment for writing applets and applications in Java.; See also applet and Java.
Javadoc: A tool from Sun Microsystems, Inc. that generates API documentation in HTML format from comments in Java source code. The Java API Reference document is formatted by the Javadoc tool.; See also application programming interface (API).
Java Enterprise Tuxedo (JET): An API that allows a WebLogic Enterprise Java server object to access existing BEA Tuxedo services using the transactional model specified by the Java Transaction API (JTA).
Java IDL: Provides standards-based interoperability and connectivity through CORBA, the open industry standard for heterogeneous computing. Java IDL enables seamless interoperability and connectivity to heterogeneous enterprise information assets.; To use Java IDL, you will need both the idltojava compiler and the current release of the JDK1.2 software. The idltojava compiler generates portable client stubs and server skeletons that work with any CORBA-compliant ORB implementation. The JDK 1.2 software includes CORBA API and a CORBA-compliant ORB that allows Java applications to invoke remote CORBA objects through IIOP.
Java interface: A declaration used in the Java language to define an abstract interface. Since Java does not have multiple inheritance, a Java class can implement one or more interfaces to provide mix-in functionality.; See also IDL interface.
Java Naming and Directory Interface (JNDI): A standard extension to the Java platform, providing Java technology-enabled applications with a unified interface to multiple naming and directory services in the enterprise. As part of the Java Enterprise API set, JNDI enables seamless connectivity to heterogeneous enterprise naming and directory services.
Java Native Interface (JNI): A standard Java interface that allows Java code to call C or C++ functions, or C or C++ functions to call Java code.
Java Runtime Environment (JRE): A subset of the Java Development Kit that is suitable for redistribution and sufficient for end users. The JRE consists of the Java Virtual Machine (JVM), the Java core classes, and supporting files.; See also core class and Java Virtual Machine (JVM).
JavaServer: A server process provided by the WebLogic Enterprise system that loads the JVM and then your object classes (CORBA, Java, or EJB). You configure the JavaServer in the application's UBBCONFIG file and start the JavaServers with the tmboot command.; See also Java Virtual Machine (JVM).
Java Transaction API (JTA): A high-level application transaction interface and a Java mapping to XA. Allows an application to control user transaction boundaries. The XA interface allows an external transaction manager to control transaction boundaries for operations performed by multiple resource managers using the two-phase commit X/Open XA protocol. The API is defined in the javax.transaction package.; See also application programming interface (API).
Java Transaction Service (JTS): The Sun Microsystems, Inc. Java Transaction API that specifies a standard mapping of the OMG Object Transaction Service (OTS). The JTS defines a low-level transaction management specification intended for vendors who provide the transaction system infrastructure required to support the application run-time environment. CORBA Java client applications use JTS.; See also CORBAservices Object Transaction Service (OTS).
Java Virtual Machine (JVM): The part of the Java Runtime Environment responsible for interpreting Java bytecodes.; See also Java Runtime Environment (JRE).
JDBC: See Java Database Connectivity (JDBC).
JDBC Connection Pooling: A mechanism to maintain a cache of reusable database connections. The JDBC 2.0 Standard Extension API defines interfaces between the connection pooling module and the database connections.
JDK: See Java Development Kit (JDK).
JET: See also Java Development Kit (JDK).
JET Class Library: A set of Java classes that allows the user to write Java programs to access BEA Tuxedo services.
JNDI: See Java Naming and Directory Interface (JNDI).
JRAD: See Jolt Server Handler (JSH).
joint client/server application: An application that executes code that acts as the starter for some business actions, and also executes method code for invocations on objects.; See also native joint client/server application.
Jolt Relay (JRLY): A standalone program that routes Jolt messages from Jolt clients to the Jolt Server Listener (JSL) or Jolt Server Handler (JSH) via the Jolt Relay Adapter (JRAD). Jolt Relay is not a BEA Tuxedo server or BEA Tuxedo client.
Jolt Relay Adapter (JRAD): A BEA Tuxedo application server that does not include any BEA Tuxedo services. It requires command line arguments in order to work with the JSL and the BEA Tuxedo system. The JRAD may or may not be located on the same BEA Tuxedo host machine and server group to which the JSL server is connected.
Jolt Repository: A subsystem in Jolt that provides primitive services and storage for the service definitions.
Jolt Server Handler (JSH): A program that runs on a BEA Tuxedo server machine to provide a network connection point for remote clients. The JSH works with the Jolt Server Listener (JSL) to provide client connectivity with the BEA Tuxedo system.; See also IIOP Handler (ISH) and Workstation handler (WSH).
Jolt Server Listener (JSL): A program that supports clients on an IP/port combination. The JSL works with the Jolt Server Handler (JSH) to provide client connectivity to the backend of the Jolt system. The JSL is administered by the same tools used to manage any resource within a BEA Tuxedo environment.; See also IIOP Listener (ISL) and Workstation listener (WSL).
JRE: See Java Runtime Environment (JRE).
JRLY: See Jolt Server Handler (JSH)
JREPSVR: A BEA Tuxedo server that provides services to access the Jolt Repository storage. It provides support for Jolt run-time environment and minimum editing and query functions.
JSH: See Jolt Server Handler (JSH).
JSL: See Jolt Server Listener (JSL).
JTA: See Java Transaction API (JTA).
JVM: See Java Virtual Machine (JVM).

- K -

(No terms starting with the letter "K")

- L -