1
Overview

This chapter gives you a general picture of distributed object development in the Oracle9i JVM. As with the more specific chapters that follow, this overview focuses on the aspects of CORBA development that are particular to Oracle9i, giving a brief general description of the standard CORBA development model.

This chapter covers the following topics:

• Prerequisite Reading

• Terminology

• About CORBA

• Using JNDI and IIOP

• For More Information

Prerequisite Reading

Before consulting this Guide, you should read the Oracle9i Java Developer's Guide, which gives you the technical background information necessary to understand Java in the database server. As well as a comprehensive discussion of the advantages of the Oracle9i implementation for enterprise application development, it explains the fundamentals of the Oracle9i JVM and gives a technical overview of the Oracle9i tools.

In addition, the Oracle9i Java Developer's Guide describes the strategic advantages of the distributed component development model that is implemented by CORBA.

Terminology

This section defines some of the basic terms used in this chapter. See also Appendix C, "Abbreviations and Acronyms", for a list of common acronyms used in Java and distributed object computing.

client

A client is an object, an application, or an applet that makes a request of a server object. Remember that a client need not be a Java application running on a workstation or a network computer, nor an applet downloaded by a Web browser. A server object can be a client of another server object. Client refers to a role in a requestor/server relationship, not to a physical location or a type of computer system.

marshalling

In distributed object computing, marshalling refers to the process by which the ORB passes requests and data between clients and server objects.

object adapter

Each CORBA ORB implements an object adapter (OA), which is the interface between the ORB and the message-passing objects. CORBA 2.0 specifies that a basic object adapter (BOA) must exist, but most of the details of its interface are left up to individual CORBA vendors. Future CORBA standards will require a vendor-neutral portable object adapter (POA).

request

A request is a method invocation. Other names sometimes used in its stead are method call and message.

server object

A CORBA server object is a Java object activated by the server, typically on a first request from a client.

session

A session always means a database session. Although it is conceptually the same type of session as that established when a tool such as SQL*Plus connects to Oracle, there are differences in the CORBA case, as follows:

• You establish the database session using the IIOP protocol; you establish a SQL*Plus session using the Oracle Net Services TTC protocol.

• A JVM that runs in the database server controls an IIOP session.

  Note: To use CORBA with Oracle9i, you must configure the database so that the listener can recognize incoming IIOP requests, in addition to TTC requests. DBAs and system administrators should see Chapter 3, "Configuring IIOP Applications" for information on setting up the database and the listener to accept incoming IIOP requests.

See "Session IIOP Service" for more information about sessions.

About CORBA

CORBA stands for Common Object Request Broker Architecture. What is common about CORBA is that it integrates ideas from several of the original proposers. CORBA is deliberately vendor neutral. The CORBA architecture specifies a software component, a broker, that mediates and directs requests to objects that are distributed across one or more networks, which might have been written in a different language from that of the requestor, and which might be running on different hardware from that of the requestor.

CORBA enables your application to tie together components from various sources. Also, and unlike a typical client/server application, a CORBA application is not inherently synchronous. It is not necessarily typical that a CORBA requestor (a client) invokes a method on a server component and waits for a result. Using asynchronous method invocations, event interfaces and callbacks from server object to the client ORB, you can construct elaborate applications that link together many interacting objects and that access one or many data sources and other resources under transactional control.

CORBA offers a well-supported international standard for cross-platform, cross-language development. CORBA supports cross-language development by specifying a neutral language, Interface Definition Language (IDL), in which you develop specifications for the interfaces that the application objects expose.

CORBA supports cross-platform development by specifying a transport mechanism, IIOP, that allows different operating systems running on very different hardware to interoperate. IIOP supplies a common software bus that, together with an ORB running on each system, makes data and request transfer transparent to the application developer.

Although the CORBA standard was developed before the advent of Java and is a standard focused on component development in a heterogeneous application development environment, incorporating systems and languages of varying age and sophistication, it is possible to develop CORBA applications solely in Java.

For CORBA developers, Oracle9i offers the following services and tools:

• a Java Transaction API (JTA) interface, which implements the Sun Microsystems specification

• a Java Transaction Service (JTS) interface to the OMG Object Transaction Service (OTS)

• a CosNaming implementation used for publishing objects to an Oracle9i database, retrieving the object references, and activating objects

• a version of the IIOP protocol that supports the Oracle9i session-based ORB, which is compatible with standard IIOP

• a wide range of tools, which assist in developing CORBA applications, that do the following:
  • load Java classes and resource files into the database

  • drop loaded classes

  • publish objects to the CosNaming service

  • manage the session name space

CORBA Features

CORBA achieves its flexibility in several ways:

• It specifies an interface description language (IDL) that allows you to specify the interfaces to objects. IDL object interfaces describe, among other things:
  • The data that the object makes public.

  • The operations to which the object can respond, including the complete signature of the operation. CORBA operations map to Java methods, and the IDL operation parameter types map to Java datatypes.

  • Exceptions that the object can throw. IDL exceptions also map to Java exceptions, and the mapping is very direct.

    CORBA provides bindings for many languages, including both non-object languages such as COBOL and C, and object-oriented languages such as Smalltalk and Java.

• All CORBA implementations provide an object request broker (ORB) that handles the routing of object requests in a way that is largely transparent to the application developer. For example, requests--or method invocations--on remote objects that appear in the client code look like local method invocations. The remote call functionality, including marshalling of parameter and return data, is performed for the programmer by the ORB.

• CORBA specifies a network protocol, the Internet Inter-ORB Protocol (IIOP), that provides for transmission of ORB requests and data over a widely available transport protocol: TCP/IP, the Internet standard.

• A set of fully-specified services eases the burden of application development by making it unnecessary for the developer to constantly reinvent the wheel. Among these services are:
  • Naming--One or more services that enable you to resolve names that are bound to CORBA server objects.

  • Transactions--Services that enable you to manage transaction control of data resources in a flexible and portable way.

  • Events.

  CORBA specifies more than 12 services; however, most of these are not currently implemented by CORBA ORB vendors.

The remainder of this section introduces some of the essential building blocks of an Oracle9i CORBA application. These include:

• ORB--how to talk to remote objects

• IDL--how to write a portable interface

• naming service (and JNDI)--how to locate a persistent object

• object adapters--how to register a transient object

About the ORB

The object request broker (ORB) is the fundamental part of a CORBA implementation. The ORB makes it possible for a client to send messages to a server, and the server to return values to the client. The ORB handles all communication between a client and a server object.

The Oracle9i ORB is based on code from Inprise's VisiBroker 3.4 for Java. The ORB that executes on the server side has been slightly modified from the VisiBroker code, to accommodate the Oracle9i object location and activation model. The client-side ORB has been changed very little.

Note: The VisiBroker ORB functionality supplied with Oracle9i is only licensed for accessing Oracle9i servers.

In some CORBA implementations, the application programmer and the server object developer must be aware of the details of how the ORB is activated on the client and the server, and they must include code in their objects to start up the ORB and activate objects. The Oracle9i ORB, on the other hand, makes these details largely transparent to the application developer. Only in certain circumstances does the developer need to control the ORB directly. These occur, for example, when coding callback mechanisms or when there is a need to register transient objects with the basic object adapter.

Using JNDI and IIOP

You publish CORBA objects in the Oracle database using the OMG CosNaming service. In addition, you can access these objects using Oracle's JNDI interface to CosNaming.

Figure 1-1 shows how applications access remote objects published in the database, using JNDI.

Figure 1-1 Remote Object Access

Text description of the illustration overviea.gif

IIOP

Oracle9i offers a Java interpreter for the IIOP protocol. Oracle embeds a pure Java ORB of a major CORBA vendor--VisiBroker for Java version 3.4 by Inprise. Oracle9i repackaged the Visigenic Java IIOP interpreter to run in the database.

Because Oracle9i is a highly scalable server, only the essential components of the interpreter are necessary--namely, a set of Java classes that do the following:

• decode the IIOP protocol

• find or activate the relevant Java object

• invoke the method that the IIOP message specifies

• write the IIOP reply back to the client

Oracle9i does not use the ORB scheduling facilities. The Oracle multi-threaded server performs the dispatching and enables the server to process IIOP messages efficiently and in a highly scalable manner.

On top of this infrastructure, Oracle9i implements both the EJB and CORBA programming models.

For More Information

This section lists some resources that you can access to get more information about CORBA and application development using Java.

Books

The ORB and some of the CORBA services that Oracle9i JVM supplies are based on VisiBroker for Java code licensed from Inprise. Programming with VisiBroker, by D. Pedrick et al. (John Wiley and Sons, 1998), provides both an introduction to CORBA development from the VisiBroker point of view and an in-depth look at the VisiBroker CORBA environment.

Client/Server Programming with Java and CORBA, by R. Orfali and D. Harkey (John Wiley and Sons, 1998), covers CORBA development in Java. This book also uses the VisiBroker implementation for its examples.

You should be aware that the examples published in both of these books require some modification to run in the Oracle9i ORB. It is better to start off using the demos provided with Oracle9i, which are more extensive than the examples in the books cited, and demonstrate all the features of Oracle9i CORBA. See also Appendix B, "Comparing the Oracle9i and VisiBroker VBJ ORBs" for a discussion of the major differences between VisiBroker for Java and the Oracle9i implementation.

URLs

You can download specifications for CORBA 2.0 and for CORBA services from links available at the following web site:

http://www.omg.org/library/downinst.html

Documentation on Inprise's VisiBroker for Java product is available at:

http://www.inprise.com/techpubs/visibroker/visibroker33/