Question

State whether each of the following is true or false. If false, explain why. a) RMI uses the same underlying communication protocol as CORBA. b) TIEs are POAs that use the delegation model. c) The Event Service allows only one delivery model at a time: Either pull or push, but not both. d) Session CORBAcomponents are equivalent to EJB stateless session beans. e) Session CORBAcomponents are equivalent to EJB stateful session beans. f) Enterprise JavaBeans specify the use of an Event Service. g) CCM supports multithreaded containers.

Short answer

a) False, b) True, c) False, d) True, e) False, f) False, g) True.

Step-by-step solution

Analyze Statement a

The statement claims that RMI (Remote Method Invocation) uses the same underlying communication protocol as CORBA (Common Object Request Broker Architecture). RMI mainly uses Java RMI (JRMP) and IIOP (Internet Inter-ORB Protocol), while CORBA uses IIOP. Although RMI can use IIOP, traditionally they do not use the same protocol by default. The default JRMP is different from CORBA's IIOP. Conclusion: False.

Analyze Statement b

The statement claims that TIEs (Transport Independence Elements) are Portable Object Adapters (POAs) that use the delegation model. TIEs are indeed a form of POA, allowing different languages to interact within CORBA, and they often use the delegation model where method calls are delegated to a servant object. Conclusion: True.

Analyze Statement c

The statement claims that the CORBA Event Service allows only one delivery model at a time. In reality, the Event Service supports both push and pull models simultaneously, allowing flexibility in event delivery. Conclusion: False.

Analyze Statement d

The statement compares session CORBAcomponents with EJB stateless session beans. Session CORBAcomponents, like EJB stateless session beans, do not retain any client state between calls, making them comparable. Conclusion: True.

Analyze Statement e

The statement compares session CORBAcomponents with EJB stateful session beans. Stateful session beans maintain a conversational state between method calls, unlike session CORBAcomponents, which do not retain state. Conclusion: False.

Analyze Statement f

The statement claims that Enterprise JavaBeans specify the use of an Event Service. EJB does not inherently specify the use of an Event Service; EJB uses a different mechanism for events like message-driven beans. Conclusion: False.

Analyze Statement g

The statement claims that Container Component Model (CCM) supports multithreaded containers. CCM is designed to allow multithreaded execution, leveraging the capabilities of CORBA to manage multiple requests concurrently. Conclusion: True.

Key concepts

RMI (Remote Method Invocation)

Remote Method Invocation (RMI) is a Java programming API that allows objects to communicate remotely with each other. It enables Java developers to write distributed applications where objects located on different machines can interact over a network.
RMI works by letting Java objects call methods on objects located on other Java Virtual Machines (JVMs). This is similar to how a local method call works, making it relatively simple for developers to use.
One core concept of RMI is the use of "stubs" and "skeletons." A stub acts as a proxy on the client side, sending method calls to the server. Conversely, the skeleton on the server side receives these calls and processes them.
RMI usually uses the Java Remote Method Protocol (JRMP) for communication. However, it can also be configured to use the Internet Inter-ORB Protocol (IIOP) to communicate with CORBA systems, making it versatile in distributed architecture.

CORBA (Common Object Request Broker Architecture)

The Common Object Request Broker Architecture (CORBA) is a standard defined by the Object Management Group (OMG) for software componentry. It allows software components written in different languages and running on different machines to work together.
CORBA enables this cross-platform capability by using an Object Request Broker (ORB), which acts as a central hub for communication among objects. The use of an Interface Definition Language (IDL) is crucial in CORBA as it specifies the interfaces that objects present to the outer world.
This architecture also includes services like the Naming Service and the Event Service, which handle name context mapping and support event-driven communication models respectively. An important feature of CORBA is the flexibility in using push and pull models simultaneously, allowing it to manage various event delivery methods smoothly.

Enterprise JavaBeans (EJB)

Enterprise JavaBeans (EJB) is a robust component of the Java EE platform that simplifies the development of enterprise-level applications. It allows developers to create scalable, transactional, and multi-tiered applications quickly.
EJBs come in three main types:

• Session Beans (Stateless and Stateful) - used for logic that can be distributed across different requests.
• Entity Beans - helpful in maintaining data persistence.
• Message-Driven Beans - enable asynchronous communication.

While EJBs do not incorporate an Event Service like CORBA, they provide powerful functionality like lifecycle management and transaction support. This makes them highly suitable for handling backend business logic and complex processes in enterprise applications.

IIOP (Internet Inter-ORB Protocol)

The Internet Inter-ORB Protocol (IIOP) is a protocol used within CORBA to facilitate communication between different ORBs. Its main purpose is to ensure interoperability among distributed systems over the internet.
IIOP acts as a middle layer that seamlessly translates requests and responses between diverse ORBs, allowing components written in any programming language to communicate effectively. This capability is crucial for distributed applications that require components spread across various platforms.
By using IIOP, developers can ensure that their CORBA-based systems maintain consistent communication, making it easier to integrate and scale applications across different networks. IIOP's reliability and efficiency are pivotal in supporting enterprise-grade applications that demand high levels of concurrent processing.