We using a Parlay based CORBA interface that we want to access on a J2EE platform. The interface recognizes a remote "service layer" and a local "application layer". The remote "service layer" contains several classes (each having a different CORBA interface description). Each of these classes has an associated callback class in the "application layer". This means that both "service layer" and "application" are CORBA servers and clients.
The behavior of the interface is typically session oriented. An action inside the "service layer" will initiate a new session. A session will typically contain one instance of a certain class, multiple instances of another class (and perhaps multiple instances of a third class). Each of these instances will have its unique corresponding callback instance in the "application layer". Actions on the "service layer" are mostly asynchronous; e.g. serviceInstance.actionReq() is called by the application on the "service layer" and the callbackInstance.actionRes() or callbackInstance.actionErr() are called by the service on the "application layer".
An example of such a session is a telephony call. A "telephonyCall" instance is located in the "service layer" and has multiple "telephonyCallLeg" instances (multiple in case of a telephony conference). In the "application layer" a "telephonyCallCB" callback instance and multiple "telephonyCallLegCB" callback instances are present (associated with their corresponding instances in the service layer). Different callback instances are needed to distinguish events happening in the telephone conference from one another (e.g. one caller hangs up, another presses a digit on its phone).
Aside from the handling of the sessions, the "application layer" will also need to perform some "management related" tasks, e.g. periodically checking if the "service layer" is still available, (for a particular application) registering for certain incoming sessions (e.g. telephone calls directed to particular numbers), or starting a new outgoing session (e.g. initiating an outgoing telephone call).
The CORBA IDL is used to generate stub files for both "application layer" and "service layer". There is no interface repository available.
Now, given a J2SE environment, the "application layer" can be perfectly modeled, either by using the generated stub files, implementing the (CORBA) callback objects and accessing the remote objects. Different "applications" each can have their own ORB, providing a nice separation of functionality.
For J2EE it is unclear for us how to proceed. It is essential that (for a given session) an application is aware of the different callback interfaces, as it needs to react on the events (invocations) on the different interfaces. It must be possible for different "applications" to register for different sessions (e.g. one application handles telephone calls for number X, another application for number Y). We have considered using JCA to "wrap" the CORBA based interface, but we are unsure how we can / need to approach this.
Any help, info or suggestion is appreciated.