A tightly coupled integration between .NET and J2EE, thanks to IIOP and CORBA

Hi folks,

These days loosely coupled sort of integrations are much more common especially using SOA as the business processes are becoming more dynamic and object-based development platforms are increasing, but I don’t think it means tightly coupled ones are defunct.
In fact I believe if there is a stable way to integrate heterogeneous systems (.NET and J2EE in our case) in a tightly coupled manner, the cost of integration through that will be less than solutions such as SOA as it could provide a real stateful distributed object system.

How many of you have ever heard of CORBA (Common Object Request Broker Architecture)? How about IIOP or IIOP.NET?
Well, I’m going to write about ORB, CORBA, and a little bit for those that have no idea what it is and from there I’m going to show you how a .NET based ORB can help us to develop a tightly coupled integration between .NET and J2EE.

The following picture shows the basic concept behind an ORB. The general purpose of an ORB is to provide communication between different elements of application software. The application software providing a service is represented by an object. This object encapsulates software which might not be an object oriented one.
A client can request services from an object by sending request through the ORB.
The benefit of this approach is that it reduce the amount of code that need to be written to create an application client and have it interoperate in a distributed environment.

CORBA is OMG’s vendor-independent architecture that defines true interoperability by specifying how ORBs from different vendors can communicate.
Following figure shows some of the finer grained details from the CORBA model.

The shaded section between the Application Software and the ORB infrastructure is the only part of the infrastructure standardized by CORBA.
CORBA does not standardize the underlying mechanisms. The consequence of this is that the selected underlying mechanisms may not be compatible across different vendors.
To resolve this issue an additional standard called Internet Inter ORB Protocol (IIOP) has been defined to specify how different ORB mechanisms can interoperate transparently.

Now let’s turn our attention to IIOP .NET. It’s a .NET remoting channel based on IIOP. IIOP .NET acts as an ORB and converts .NET’s CTS to CORBA’s type system and vice versa, making the objects defined in your .NET application accessible to other ORBs such as RMI-IIOP, what denotes Java’s RMI (Remote Method Invocation) interface over IIOP.
That was what I wanted to pointed out. Two IIOP based remote type of method invocations (Remoting in .NET and RMI in Java) can implement and reference each other’s objects.
There have been other projects in this arena. But it looks that this one (IIOP .NET) is the most proven one.
To see a fine sample and descriptive article about it please refer to the following URL:
http://www.codeproject.com/csharp/dist_object_system.asp

I'm really keen to know is there anybody out there has experienced development using IIOP .NET. What was the issues you were facing? How did you resolve them?
I appreciate your comments in advance.