CORBA Programming with Java.
This course teaches you how to write Common Object Request Broker Architecture (CORBA) clients and servers in Java. CORBA is a powerful approach to component programming that permits interoperability in almost every respect:
Your clients and servers can be written in different languages, can be running on different machines, and can be written for different platforms. A C++ client running on a Windows machine can communicate with a Java server running on a UNIX machine, for example.
In this course, you will build on your knowledge of CORBA fundamentals, the Java language, and the Java Development Kit (JDK). You will start by seeing how CORBA Interface Definition Language (IDL) and Java code are related, then move on to simple servers and clients.
You will explore the Naming Service, the Basic Object Adapter (BOA), the Portable Object Adapter (POA), persistent servers, CORBA patterns, and finally the connection between CORBA and the Internet, specifically the Web.
Design Corba Systems
When designing CORBA (Common Object Request Broker Architecture) systems using Java, there are several important considerations to take into account to ensure an efficient and robust implementation. These considerations include the following:
- IDL (Interface Definition Language) design: The IDL is the cornerstone of any CORBA system, as it defines the interfaces that objects present to the outside world. It's crucial to design these interfaces carefully, keeping them as simple and intuitive as possible. You should also strive to keep the IDL definitions language-agnostic even though you're using Java, as one of the primary benefits of CORBA is its language interoperability.
- Exception handling: CORBA uses a specific mechanism for exception handling that is distinct from that of the Java language. Make sure to correctly map CORBA exceptions to their Java equivalents, and vice versa, to ensure that the system behaves correctly in exceptional circumstances.
- Object Lifecycle Management: Decide on how to create and destroy CORBA objects, considering the lifetime, persistence, and performance requirements. There are different servant (server-side object) management policies offered by the Portable Object Adapter (POA), like the RETAIN and NON_RETAIN policies.
- Concurrency and threading: Care must be taken when dealing with concurrent requests in a multi-threaded environment. Use appropriate synchronization techniques to protect shared resources.
- Use of CORBA Services: CORBA provides a variety of services such as Naming Service, Event Service, Transaction Service, and more. Determine which ones are needed and design their usage carefully to avoid performance bottlenecks or architectural issues.
- Versioning and backward compatibility: When updating the system, ensure that changes to IDL interfaces remain backward compatible to avoi breaking existing clients.
- Performance and Scalability: When designing CORBA systems, consider factors such as the number of requests per second the system must handle, the amount of data to be processed, and the number of clients that will connect to the system. Optimizations might be necessary to meet these requirements.
- Security: Ensure that appropriate security measures are in place, including secure communication channels and authentication mechanisms. Use the CORBA Security Service when necessary.
Designing CORBA systems with these considerations in mind will help ensure a robust, reliable system that is capable of integrating with other components, regardless of their programming language or platform.
After completing the course, you will be able to:
- Predict the Java code that is generated for a specific IDL
- Use tie classes and inheritance to implement a CORBA server
- Write a simple CORBA client that obtains a server reference and invokes a server method
- Write code to add a server to the Naming Service
- Write code to find a server in the Naming Service
- Choose POA policies for your CORBA objects
- Write code to create persistent server objects
- Use JacORB utilities to implement persistency
- Determine the appropriate granularity for your interfaces
- Use design patterns to improve your CORBA solutions
- Use callbacks to code a self-updating client
- Explain IIOP, the Internet Inter-ORB Protocol
- Explain how IIOP tunneling gets through firewalls
In this course, you will learn and practice CORBA skills with two kinds of sinulation:
- the Slide Show and
CORBA Programming with Java is the second of two courses in the CORBA series. The first course which is available on this website is called Corba Fundamentals.
In the next lesson, thet prerequisites for the course will be discussed.