Distributed Computing – CORBA (Common Object Request Broker Architecture)

CORBA, which stands for Common Object Request Broker Architecture, is a middleware technology that enables the communication and interaction of distributed objects across different programming languages and platforms. It provides a standardized way for objects to invoke methods on remote objects, regardless of their location or the programming language they are implemented in. In this article, we will explore CORBA in the context of Java, its architecture, and provide code examples to illustrate its usage.

1. Introduction to CORBA

CORBA is a middleware technology that allows objects to communicate and invoke methods on remote objects, often referred to as “remote method invocation.” It offers a language-independent and platform-independent mechanism for building distributed systems.

2. CORBA Architecture

CORBA applications are structured as follows:

2.1. Object Request Broker (ORB)

The Object Request Broker is the central component of a CORBA application. It acts as an intermediary between clients and server objects. The ORB handles object references, method invocations, and marshalling/unmarshalling of data between different languages and platforms.

2.2. Interface Definition Language (IDL)

The Interface Definition Language is used to define the interface of remote objects. IDL is language-neutral and serves as the contract between clients and servers. It specifies the methods and data structures that a remote object provides.

2.3. Server Objects

Server objects implement the interfaces defined in IDL. These objects expose their methods to clients and can be located on remote servers.

3. Creating a CORBA Application in Java

Let’s create a simple CORBA application in Java. We will define an IDL interface, implement a server object, and create a client application to invoke remote methods.

3.1. IDL Interface

Define an IDL interface named Calculator that specifies a method for adding two numbers:

module CalculatorApp {
    interface Calculator {
        long add(in long a, in long b);
    };
};

3.2. Server Object

Implement a server object that provides the implementation of the Calculator interface:

import CalculatorApp.Calculator;
import org.omg.CORBA.ORB;

class CalculatorImpl extends Calculator {
    public long add(long a, long b) {
        return a + b;
    }
}

3.3. Server Application

Create a server application that registers the server object with the ORB:

import CalculatorApp.Calculator;
import CalculatorApp.CalculatorHelper;
import org.omg.CORBA.ORB;

public class Server {
    public static void main(String[] args) {
        try {
            ORB orb = ORB.init(args, null);
            CalculatorImpl calculatorImpl = new CalculatorImpl();

            org.omg.CORBA.Object ref = orb
                .resolve_initial_references("RootPOA")
                .servant_to_reference(calculatorImpl);
            Calculator calculator = CalculatorHelper.narrow(ref);

            orb.run();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

3.4. Client Application

Create a client application that connects to the server and invokes the remote method:

import CalculatorApp.Calculator;
import CalculatorApp.CalculatorHelper;
import org.omg.CORBA.ORB;

public class Client {
    public static void main(String[] args) {
        try {
            ORB orb = ORB.init(args, null);
            org.omg.CORBA.Object objRef = orb
                .string_to_object("corbaname::localhost:1050#CalculatorServer");
            Calculator calculator = CalculatorHelper.narrow(objRef);

            long result = calculator.add(5, 3);
            System.out.println("Result: " + result);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

4. Running the CORBA Application

To run the CORBA application, follow these steps:

1. Compile the IDL interface using the idlj compiler.
2. Compile the server and client Java classes.
3. Start the server using the Server class.
4. Run the client using the Client class.

5. Conclusion

CORBA is a powerful middleware technology that enables the creation of distributed systems by allowing objects to communicate and invoke methods remotely. In Java, it provides a seamless way to create distributed applications that can interact with objects implemented in different languages and on different platforms. While CORBA has become less popular in recent years, it remains a fundamental technology in the realm of distributed computing.