BEA Logo BEA WebLogic Enterprise Release 5.0

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

 

   WLE Doc Home   |   CORBA Programming & Related Topics   |   Previous   |   Next   |   Contents   |   Index

Creating CORBA C++ Server Applications

This document describes how programmers can implement key features in the BEA WebLogic Enterprise (WLE) product to design and implement scalable, high-performance, C++ server applications that run in a WLE domain. The C++ examples shown in this book are based on the sample applications described in the Guide to the University Sample Applications.

This document is intended for programmers who are interested in creating secure, scalable, transaction-based server applications. It assumes your are knowledgeable with the BEA TUXEDO system, CORBA, and C++ programming.

This document contains the following topics:

 

Server Application Concepts

The Entities You Create to Build a WLE Server Application

   The Implementation of the CORBA Objects for Your Server Application

      How Interface Definitions Establish the Operations on a CORBA Object

      How You Implement the Operations on a CORBA Object

      How Client Applications Access and Manipulate Your Application's CORBA Objects

      How You Instantiate a CORBA Object at Run Time

   The Server Object

Process for Developing WLE Server Applications

   Generating Object References

      How Client Applications Find Your Server Application's Factories

      Creating an Active Object Reference

   Managing Object State

      About Object State

      Object Activation Policies

      Application-Controlled Deactivation

   Reading and Writing an Object's Data

      Available Mechanisms for Reading and Writing an Object's Durable State

      Reading State at Object Activation

      Reading State Within Individual Operations on an Object

      Stateless Objects and Durable State

      Stateful Objects and Durable State

      Your Responsibilities for Object Deactivation

      Avoiding Unnecessary I/O

      Sample Activation Walkthrough

   Using Design Patterns

      Process-Entity Design Pattern

      List-Enumerator Design Pattern

 

Steps for Creating a WLE Server Application

Summary of the WLE Server Application Development Process

Step 1: Compile the OMG IDL file for the server application.

   Using the IDL Compiler

   Generating the Skeleton and Implementation Files

   Generating Tie Classes

Step 2: Write the methods that implement each interface's operations.

   The Implementation File Generated by the IDL Compiler

   Implementing a Factory

Step 3: Create the Server object.

   Initializing the Server Application

   Writing the Code That Creates and Registers a Factory

   Creating Servants

   Releasing the Server Application

Step 4: Define the in-memory behavior of objects.

   Specifying Object Activation and Transaction Policies in the ICF File

Step 5: Compile and link the server application.

Step 6: Deploy the server application.

Development and Debugging Tips

   Use of CORBA and M3 Exceptions and the User Log

      Client Application View of Exceptions

      Server Application View of Exceptions

   Detecting Error Conditions in the Callback Methods

   Common Pitfalls of OMG IDL Interface Versioning and Modification

   Caveat for State Handling in Tobj_ServantBase::deactivate_object()

Servant Pooling

   How Servant Pooling Works

   How You Implement Servant Pooling

Delegation-based Interface Implementation

   About Tie Classes in the WebLogic Enterprise System

   When to Use Tie Classes

   How to Create Tie Classes in a WebLogic Enterprise Application

 

Designing and Implementing a Basic WLE Server Application

How the Basic University Sample Application Works

   The Basic University Sample Application OMG IDL

   Application Startup

   Browsing Course Synopses

   Browsing Course Details

Design Considerations for the University Server Application

   Design Considerations for Generating Object References

   Design Considerations for Managing Object State

      The RegistrarFactory Object

      The Registrar Object

      The CourseSynopsisEnumerator Object

      Basic University Sample Application ICF File

   Design Considerations for Handling Durable State Information

      The Registrar Object

      The CourseSynopsisEnumerator Object

      Using the University Database

   How the Basic Sample Application Applies Design Patterns

      Process-Entity Design Pattern

      List-Enumerator Design Pattern

   Additional Performance Efficiencies Built into the WLE System

   Preactivating an Object with State

      How You Preactivate an Object with State

      Usage Notes for Preactivated Objects

 

Security and WLE Server Applications

Overview of Security and WLE Server Applications

Design Considerations for the University Server Application

   How the Security University Sample Application Works

   Design Considerations for Returning Student Details to the Client Application

 

Integrating Transactions into a WLE Server Application

Overview of Transactions in the WLE System

Designing and Implementing Transactions in a WLE Server Application

   How the Transactions University Sample Application Works

   Transactional Model Used by the Transactions University Sample Application

   Object State Considerations for the University Server Application

      Object Policies Defined for the Registrar Object

      Object Policies Defined for the RegistrarFactory Object

      Using an XA Resource Manager in the Transactions Sample Application

   Configuration Requirements for the Transactions Sample Application

Integrating Transactions in a WLE Client and Server Application

   Making an Object Automatically Transactional

   Enabling an Object to Participate in a Transaction

   Preventing an Object from Being Invoked While a Transaction Is Scoped

   Excluding an Object from an Ongoing Transaction

   Assigning Policies

   Opening an XA Resource Manager

   Closing an XA Resource Manager

Transactions and Object State Management

   Delegating Object State Management to an XA Resource Manager

   Waiting Until Transaction Work is Complete Before Writing to the Database

Notes on Using Transactions in the WLE System

User-Defined Exceptions

   Defining the Exception

   Throwing the Exception

 

Wrapping a BEA Tuxedo Service in an Object

Overview of Wrapping a BEA Tuxedo Service

   Designing the Object That Wraps the BEA Tuxedo Service

   Creating the Buffer in Which to Encapsulate BEA Tuxedo Service Calls

   Implementing the Operations That Send Messages to and from the BEA Tuxedo Service

   Restrictions

Design Considerations for the Wrapper Sample Application

      How the Wrapper University Sample Application Works

      Interface Definitions for the Billing Server Application

      Additional Design Considerations for the Wrapper Sample Application

 

Scaling a WLE Server Application

Overview of the Scalability Features Available in the WLE System

Scaling a WLE Server Application

   OMG IDL Changes for the Production Sample Application

   Replicating Server Processes and Server Groups

      Replicated Server Processes

      Replicated Server Groups

      Configuring Replicated Server Processes and Groups

   Scaling the Application Via Object State Management

   Factory-based Routing

      How Factory-based Routing Works

      Configuring for Factory-based Routing in the UBBCONFIG file

      Implementing Factory-based Routing in a Factory

      What Happens at Run Time

   Additional Design Considerations for the Registrar and Teller Objects

      Instantiating the Registrar and Teller Objects

      Ensuring That Student Registration Occurs in the Correct Server Group

      Ensuring That the Teller Object is Instantiated in the Correct Server Group

How the Production Server Application Can Be Scaled Further

Choosing Between Stateless and Stateful Objects

   When You Want Stateless Objects

   When You Want Stateful Objects