5
Synchronous Application Integration

The Oracle8i Java Virtual Machine (JVM) provides a highly scalable and available environment in which to run and execute server-oriented Java applications.

This chapter contains:

• Facilities Provided by the Oracle8i Java VM

• Developing Java Applications with the Oracle Database

• Supporting JABs on the Oracle8i Java VM: an Architectural Overview

Facilities Provided by the Oracle8i Java VM

The Oracle8i JVM has several key architectural components. This section contains:

• Core Facilities Provided by Java VM

• Core Runtime Facilities Provided by Java VM

• Integration Between Java VM and the Database

The Java VM is a 100% complete Java execution environment, complying with the Java Language Specification and the Java VM specified in the JavaSoft JDK 1.1.6 standard. It is tightly integrated with the database and has a number of components: a bytecode compiler, a garbage collector, an integrated Java class loader, and a Java-through-C compiler, all of which have been designed for optimal performance and scalability within the database environment.

It runs in the same process space and address space as the database kernel itself, sharing a number of the memory heaps and having direct access to the buffer cache of the database to avoid copying memory for optimal performance. The Java VM provides a runtime environment for Java objects. It includes the representation of all Java data structures and supports Java method dispatch. It supports all of the standard Java bytecode operations, including the Java non-recoverable exception model and Java Language-level threads. The VM's dispatch and execution model are also designed to support hybrid interpreted or compiled systems, enabling users to access Java-through-C translation for better performance.

Figure 5-1 Oracle Java VM Architecture

Core Facilities Provided by Java VM

The Java VM provides the following core functions:

• Object Memory Management: The Oracle8i Java VM allocates and frees memory in standard chunks called object memories, which can be specialized in various ways, depending on how they are to be used. Object memories provide users with four important benefits:
  • They are location transparent and can be efficiently relocated across thread, process, host, or temporal boundaries without the inherent costs of object serialization and deserialization, while maintaining the uniform reference semantics of Java. This means the Oracle VM provides sophisticated load balancing and failover while isolating users from the need to use low-level, error-prone Java threads for scalability.

  • Object memories can be specialized for optimizations in the way they are garbage collected: whether they are preinitialized in state or transactional in nature, whether they require rollback and atomic commit semantics.

  • Persistent and shared object memories can be archived efficiently to disk.

  • Object memories isolate the rest of the Java VM and Java applications from how they are themselves implemented.

• Memory Manager and Garbage Collector: The Java VM provides a garbage collector that has been optimized to provide excellent performance and scalability for the Oracle database environment. The garbage collector is responsible for automatically managing the Java memory heaps of the VM and for efficiently allocating and collecting object memories.

• Java Library Manager: The Library Manager is the component of the Java VM that provides facilities to load, store, and manage Java programs in the database. Users can interchange (both import and export) Java in three forms: source, binaries and resources, and archives. Java programs are stored as database library units (the equivalent of OS files).

• Java Class Loader: The class loader takes requests at runtime from the Java VM and locates, loads, and initializes local DBMS-stored Java classes (in Java binary, or native compiled form).

Core Runtime Facilities Provided by Java VM

The Java VM provides the following core runtime functionality:

• Bytecode Compiler: The Java VM embeds the standard Java bytecode compiler from JavaSoft, which translates standard Java source programs into standard Java.class binary representation.

• Interpretation Runtime: The Oracle8i Java VM provides a bytecode interpreter and associated Java runtime that executes standard Java binaries. The interpreter is a 100% implementation of standard Java (currently release 1.1.6) including advanced features such as Java threads and exceptions. Additionally, the runtime provides support for call-in and call-out from the host environment, native methods, and natively compiled Java modules.

• Standard Libraries: The Oracle8i Java VM supports all of the standard JDK 1.1.6 libraries except for the GUI-related component, Abstract Windowing Toolkit (AWT).

• Native Compilation: The Oracle8i Java VM provides a native code compiler to increase the execution performance of Java programs to near compiled C-language levels. The native compiler translates standard Java binaries to C executables, which are stored persistently in the database as library units and can be loaded as DLLs or .sos by the Java VM.

• Java Native Interface: The Java VM supports the Java Native Interface, which provides access to native methods.

.

However, the Java VM does provide facilities to call out from the database to C and C++ programs.

Integration Between Java VM and the Database

The Java VM interfaces with the rest of the Oracle8i database through four different mechanisms:

• JDBC Driver and Embedded SQL in Java Translator: Persistent data is stored in the Oracle database either as relational tables or as object relational tables defined using SQL. Java programs in the database access SQL and PL/SQL in the database through SQL or JDBC. For static SQL queries, you can write SQLJ applications that are simpler than JDBC. To write dynamic SQL, call JDBC.

• JDBC Driver: The VM incorporates a specialized implementation of the Oracle JDBC Driver. It corresponds to the JDBC 1.2.2 specification and to virtually all of the JDBC 2.0 specification, including support for object-relational types, collections, and LOBs. It ports the same programming APIs as the Oracle client-side JDBC/Oracle Call Interface, and Thin JDBC Drivers. This enables application developers to move Java applications onto the database without modifying application code. The only difference between the client-side JDBC drivers and the server-side driver is that Java objects in the server always execute in the context of the database connection under which they were called; as a result, the driver does not permit you to explicitly open connections.

• Embedded SQL in Java Translator: The Java VM in the server provides an embedded SQL in Java translator. You can write stored procedures and functions to the higher-level, more productive SQLJ interface. The embedded SQL in Java translator is transparently invoked by the Java VM in the server, which converts application code with embedded SQL statements into standard Java code with embedded JDBC calls. The resulting code can then be compiled by the embedded bytecode compiler of the Java VM and executed on its runtime facilities. At runtime, calls to JDBC are routed to the SQLJ runtime embedded within the database.

• Inter-Language Method Services (ILMS): ILMS is a common component within the database that manages all cross-language method dispatch between SQL, PL/SQL, Java, and with external procedures in C. SQL and PL/SQL call Java stored programs in the database through ILMS, the same mechanism that SQL uses to call PL/SQL in the database.

• CORBA Object Request Broker: The Oracle8i database integrates a Java-based CORBA 2.0 compliant Object Request Broker (ORB), Visibroker (Visigenics Java ORB), that enables you to call into and out of the database using the CORBA IIOP protocol. Java stored programs and Enterprise JavaBeans in Oracle8i can be invoked using IIOP. The database then behaves as a CORBA server. Similarly, IIOP callouts from Oracle8i enable the database to serve as a standard CORBA client. The ORB is used efficiently in Oracle8i; the Visigenics ORB components are used purely for IIOP protocol interpretation and object activation, and the Multithreaded Server kernel of the database is used for scalability. The database supports a variety of CORBA clients, including direct support for browsers such as Netscape 4.0 and middletier ORBs. Further, the CORBA facilities in the database are Java-friendly with a number of automated tools such as the automated Caffeine Java-to-IDL compiler.

• Development Tool Support: The Oracle8i Java VM provides a number of command line tools that simplify the use of the Java facilities in the database. Some of the facilities include tools to:
  • Load Java into the database and drop Java stored programs into the database

  • Automate the deployment and registration of CORBA servers in the database

  • Automate the packaging and deployment of Enterprise JavaBeans on Oracle8i

  These tools have themselves been integrated within the Oracle JDeveloper 2.0 tool.

Figure 5-2 Oracle Java VM Runtime Components

The Oracle8i Java Virtual Machine can be programmed in three specific ways:

• Java Stored Procedures

• CORBA Services Defined in Java

• Enterprise JavaBeans

Developing Java Applications with the Oracle Database

The Java VM in Oracle8i can be used to develop three types of Java applications:

• Database Stored Procedures, Triggers, and Methods: These support traditional database programmers and SQL-oriented clients of the database.

• Enterprise JavaBeans: The Java VM provides a transaction server platform for distributed Java components called Enterprise JavaBeans.

• CORBA Servers in Java: Oracle8i also enables distributed systems developers to implement CORBA servers in Java on the Java VM of the database.

The support for CORBA provided by the Oracle8i Java Virtual Machine creates an ideal platform for applications to communicate with each other in a synchronous, request-response manner. The Oracle8i JVM provides standard CORBA services including:

• A fully CORBA 2.0 compliant ORB

• Standard CORBA tools to develop CORBA applications in Java including an IDL compiler

This section contains:

• CORBA Facilities in Oracle8i

• Enterprise JavaBeans, an Overview

CORBA Facilities in Oracle8i

In addition to the IIOP and ORB facilities described earlier in this document, several additional CORBA facilities are integrated with the database:

• Transactions: The Oracle8i Java VM provides a CORBA Object Transaction Service (OTS) API through the embedded JDBC driver, which has been extended to support OTS-visible transactions. The OTS provides transactional properties to CORBA Servers implemented on the Java VM.

• Directory/Naming: The Java VM offers a standard COSNaming interface to the industry standard directory service: LDAP (the Lightweight Directory Access Protocol). You can then access EJB components in the server registered with the CORBA ORB of the database through this standards-based directory service. It also integrates a CosNaming/LDAP compliant name service, which makes it easy to register and locate distributed components.

• Object Adapter: Oracle8i provides an Object Adapter for persistent CORBA Objects. It provides two important functions: Firstly, it serves as a directory of CORBA Objects published in the database; Secondly, it helps locate and load CORBA Objects upon initial activation by CORBA clients. It is implemented as a standard database table with three pieces of information: the name of the published CORBA Object, the schema name of the publisher, and the name of the Java class implementing the CORBA Object. Since it is a database table, it is hash indexed for scalability and fast access. It can also be split across multiple database partitions to support large numbers of CORBA Objects and Enterprise JavaBeans.

• Java CORBA Services: The Oracle8i database provides a number of features that make it easy for Java programmers to develop CORBA services. Firstly, it supports Caffeine, a direct Java to IIOP mapping that eliminates the need for IDL. Secondly, it supports standard objects by value and extensible structs, which is enormously useful for Java programmers. Finally, it provides a number of other tools, including java2iiop, idl2java, and java2idl, which make application development simple.

• Security: CORBA services in the database execute in the same highly secure environment in which Enterprise JavaBeans execute, using the same three overlying layers of security: encryption through SSL over IIOP, authentication using traditional database username and password, and access control using roles and privileges.

  See Also: Oracle8i CORBA Developer's Guide and Reference

The Oracle8i Java Virtual Machine also supports the Enterprise JavaBeans component model and a number of standard EJB servers.

Enterprise JavaBeans, an Overview

Enterprise JavaBeans (EJB) is a relatively coarse-grained set of Java application logic defined as a component with clearly specified interfaces that can be efficiently executed on a host system infrastructure provided by an EJB transaction server. EJB are not arbitrary Java classes, but must obey a set of constraints imposed by the hosting server. The EJB component model provides Java application programmers a convenient and highly productive component model for server-side business logic, facilitating application code reuse and multi-tier application development in the following important ways:

No Foreign Interface Definition Language (IDL): EJB defines a high-level infrastructure and programming interface, enabling application developers to specify their component model entirely in Java, without forcing the developer to learn a foreign IDL such as CORBA or D/COM.

No Systems-Level Programming: EJB is designed around the concept of a transaction server that is responsible for providing the system-level infrastructure and services such as scalability, load balancing, connection pooling, failover, and transactions. This frees the application programmer from low-level systems software concerns. The Transaction Server takes care of transaction and state management; as a result, programmers can declaratively specify the transactional behavior of EJB components.

Variety of Execution Environments: The EJB spec has been designed to allow EJB components to be deployed and executed in many different host environments that serve as EJB Transaction Servers, including TP Monitors, Application Servers, and databases. Oracle provides a consistent model for EJB components on the Java VM integrated with Oracle8i and Oracle Application Server and sharing a common set of services between the two environments.

Variety of Communication Infrastructures: EJBs were also designed to isolate Java developers from the specific communications infrastructure that is used between the client, middletier, and database. Specifically, it enables Java developers to design and implement applications as EJB components, which are then portable to a variety of communications infrastructures including CORBA/IIOP, DCOM, and Java's own Remote Method Invocation (RMI) protocol. EJB applications are I-directionally compatible with any underlying infrastructure. Oracle has chosen to support CORBA/IIOP as its communication infrastructure.

Productivity: EJBs provide a way to declaratively rather than programmatically specify transactional and security properties on a server-side Java component. Java tools, including JDeveloper, are designed to enable Java developers to directly support EJB-specified interfaces, providing an extremely productive environment for users to combine thin clients with server-side EJB components capturing their business logic.

Open Systems Alternative: In contrast with Visual Basic components executed within the Microsoft Transaction Server, the Enterprise JavaBean facilities of Oracle8i provide two important benefits: an integrated server that provides both unparalleled data management capabilities with support for Java-based business object logic and an open, portable application solution that does not lock customers into a proprietary, vendor-specific solution.

Supporting JABs on the Oracle8i Java VM: an Architectural Overview

The Oracle8i database provides a number of facilities to make it a highly productive and scalable EJB Transaction Server. Architecturally, it integrates several different components that have been illustrated in the figure.

Figure 5-3 Oracle8i Distributed Object Architecture

This section contains:

• Session Management Facilities

• Enterprise JavaBeans Services

Session Management Facilities

The session management facilities in the server provide support for the low-level registration of IIOP invocations, provide data-dependent routing of IIOP requests to sessions, and free related resources. These facilities are provided by several different components of the multithreaded server platform of the database including:

• IIOP Listener: The listener is a component within the Oracle8i database that accesses and translates the messages received by the database across the wire. Based on the messages decoded, it invokes the dispatcher of the database as needed. The Oracle8i Listener has been extended to support the standard CORBA/IIOP binding protocol, enabling you to call into and out of the database using IIOP.

• IIOP Dispatcher: The dispatcher is a database component that schedules tasks and sessions within the database. With Oracle8i, the dispatcher has been extended to support IIOP-based method invocations. The Dispatcher in turn sends these messages to the CORBA 2.0 ORB for processing and dispatch.

• CORBA 2.0 ORB Integration: After the dispatcher invokes the ORB, the ORB marshals the IIOP method invoked, identifies the appropriate EJB component (which had been registered with the ORB) on which the invocation is to be executed, and then dispatches the message to the Java VM. The infrastructure of the ORB can also be used by EJB components in the database to call out to other distributed components, either CORBA components or EJBs on other EJB servers.

• Multithreaded Server Platform: The Oracle8i Java VM leverages the unmatched set of facilities that the Multithreaded Server provides, including load balancing, failover, data dependent routing, connection pooling, and shared memory management to make it a scalable EJB Server.

• Java VM Execution Platform: The Oracle8i Java VM provides the necessary execution environment for EJB components. Because they are standard Java application programs, they can leverage all the performance and scalability optimizations of the VM that were described earlier in this chapter.

• Persistent State Access: An EJB component in the data server accesses its persistent state: the state that persists across transaction boundaries through the JDBC driver or SQLJ translator integrated in the server. Its persistent state can be stored either as relational tables or as object relational tables.

Enterprise JavaBeans Services

In order to allow seamless interoperability across a multi-tier environment, Enterprise JavaBeans leverages a common set of Network Computing Services. The most important services include:

• Transactions: The Oracle8i Java VM provides a Java Transaction Service (JTS) API via the embedded JDBC driver that has been extended to support JTS-visible transactions. The JTS provides transactional properties to EJB components on the Java VM.

• Directory Naming: The Oracle8i Java VM offers a JNDI (Java Naming and Directory Interface) interface to any industry standard LDAP-enabled directory service. EJB components in the server can be placed in the directory service, from which they can be accessed through JNDI.

• Security: The Oracle8i database accepts a variety of security mechanisms including Secure IIOP and Secure Sockets Layer (SSL) credentials which is used today by the Netscape 4.0 Browser and is the default standard in the Intranet and Internet environments.

• Net8 Connection Manager: The connection manager has been extended to multiplex IIOP connections in addition to Net8 connections.

  See Also: Oracle8i CORBA Developer's Guide and Reference