Distributed Objects and the Enterprise

In the past several years, the term enterprise computing has become a major part of the information technology lexicon. Today, much of the major development in the area of IT technology is that of enterprise computing. But what does enterprise computing actually mean?

Perhaps the most basic definition of enterprise computing is that it's essentially distributed computing. Distributed computing is just what the name implies, a distributed group of computers working together over a network. In this context, a network can be a proprietary network or the Internet.

The power of distributed computing is that computers can share the work. In a truly distributed environment, you do not even need to know what computer is actually servicing your request—in fact, it might be better that you don't know. For example, when you shop online you connect to a company's Web site. All you know is that you are connecting using a URL. However, the company will connect you to whatever physical machine is available.

Why is this desirable? Suppose that a company has a single machine to service all the requests. Then consider what would happen if the machine crashes. Now let's suppose that the company can distribute the online activities over a dozen machines. If one of the machines goes down, the impact will not be as devastating.

The Common Object Request Broker Architecture (CORBA)
One of the primary tenets of this book is that objects are totally self-contained units. With this in mind, it doesn't take much imagination to consider sending objects over a network. In fact, we have used objects traveling over a network in many of the examples throughout this book. A Java applet is a good example of an object being downloaded from a server to a client (browser).

The entire premise of the enterprise is built on the concept of distributed objects. There are many advantages to using distributed objects; perhaps the most interesting is the fact that a system can theoretically invoke objects anywhere on the network. This is a powerful capability, and is the backbone for much of today's Internet-based business. Another major advantage is that various pieces of a system can be distributed across multiple machines across a network.

The idea of accessing and invoking objects across a network is a powerful technique. However, there is one obvious fly in the ointment—the reoccurring problem of portability. Although we can, of course, create a proprietary distributed network, the fact that it is proprietary leads to obvious limitations. The other problem is that of programming language. Suppose a system written in Java would like to invoke an object written in C++. In the best of all worlds, we would like to create a non-proprietary, language-independent framework for objects in a distributed environment. This is where CORBA comes in.

Internet Inter-ORB Protocol
Just as HTTP is the protocol for Web page transactions, IIOP (Internet Inter-ORB Protocol) is a protocol for distributed objects that can be written in a variety of programming languages. IIOP is a fundamental piece of standards like CORBA and Java RMI.


Java's Remote Method Invocation (RMI)
Although CORBA is very powerful, it is also somewhat complicated. CORBA is independent of many constraints, including programming languages. To provide interoperability across hardware platforms, operating systems, networks, and so on, a certain level of complexity is inherent. One obvious way to overcome this complexity is to limit the variables. For example, we could limit the programming language to a single language. Of course, this will impose a major constraint, but it will also make the implementation much more stable.

Java provides such an implementation called Remote Method Invocation (RMI). RMI provides many of the same functions that CORBA provides; however, it is limited to the Java programming language, and thus is not really an open industry standard.

Java 2 Standard Edition
RMI is part of the Java 2 Standard Edition (J2SE). The Java 2 SDK Standard Edition V1.4 provides many enhancements to RMI. RMI is also supported by the Java 2 Micro Edition (J2ME).

In the previous section on CORBA we related many of the concepts associated with distributed computing. RMI implements theses distributed computing concepts in a proprietary way. Although the obvious disadvantage of using a proprietary is the loss of language support, there are certain advantages. The fact that RMI is part of the core Java services means that it integrates seamlessly into any Java application you might develop. This makes the implementation much more stable. You can also take advantage of the various Java services, such as garbage collection.