JSP access CORBA service object as client side

Js| Object | Access combined with Java EE and CORBA, we can make full use of the advantages of both to build more powerful application systems, such as the CORBA object implemented by C + + as the business processing component, to form high-performance business logic layer, and to access CORBA component to build the presentation layer in JSP. Let's take a look at an example of accessing a CORBA service object in a JSP.
　　 Software Selection:
CORBA service Provider, we choose the Software Business Middleware Co., Ltd. ( http://www.inforbus.comInforbus (a distributed object middleware that follows the CORBA specification) is developed based on C + +. The operating system chooses IBM AIX (of course, you can also choose HP UNIX, Linux, or Windows).
CORBA client, in order to demonstrate CORBA's interoperability capabilities, the orb contained in the JDK is used here. Of course, as a better choice, you can also use the Java version of Inforbus to implement CORBA's client side.
JSP operating environment, we choose to create software Business Middleware Co., Ltd. ( http://www.inforbus.comInforweb (an application server that follows the Java EE specification). The operating system chooses Windows (of course, you can also choose HP UNIX, Linux, or AIX).

　　 Program Implementation
　　 IDL
IDL is the protocol that the CORBA server and the client make the request call, and the client and the service can communicate seamlessly without any relation to the development language and operating system of the client and the service party, as long as the same IDL is used. You can even choose different CORBA middleware for both the client and the service provider (as long as they follow the CORBA specification). When implementing a CORBA client program, you do not need to care about any details of the service side, all you need to care about is idl!
Here we define the IDL (file name Apptest.idl) as shown below:

1. module Example {
2. Interface A
3. Long Aoperation (in long ildata);
4. };
5. };

　　 implementation of CORBA service-side program
The main tasks of CORBA Server implementation include: mapping IDL to C + +, implementing interfaces defined in IDL (that is, implementing processing logic), and writing a main program instantiation service object to provide services.
1. Mapping IDL to C + +
This only needs to invoke Inforbus IDL compiler IDL and execute the following command:
IDL Apptest.idl
This command will produce four files: apptest.h, Apptest.cpp, Apptest_skel.cpp, Apptest_skel.cpp, which contains skeleton.
2. Implementing the interfaces defined in IDL
Inherit skeleton, implement IDL interface definition, complete your business logic in implementation class, in this example we implement a simple logic, multiply the received parameter by 2, and return the result, the code is as follows:

2. ////////////////////////////////////////
4. //filename: apptest_impl.h
6. #ifndef Apptest_impl_h
8. #define Apptest_impl_h
10. #include \ "Apptest_skel.h\"
14. class A_impl: public poa_example::a, Portableserver::refcountservantbase {
16. Public:
18. Virtual CORBA::long aoperation (CORBA::long Ildata)
20. Throw (CORBA::systemexception);
22. };
26. #endif
30. //////////////////////////////////////////////////////
32. //filename: apptest_impl.cpp
34. //contains CORBA System class library
36. #include <STARCORBA.h>
38. using namespace Std;
40. #include <apptest_impl.h>
44. implementation of//Operation Aoperation
46. CORBA::long a_impl::aoperation (CORBA::long Ildata)
48. Throw (CORBA::systemexception) {
50. CORBA::Long ret;
52. RET = Ildata * 2;
54. return ret;
56. }

3. Write a main program instantiation service object Provision service
In the main program, establish a CORBA environment, instantiate the service object and register it with the name service, and then start waiting for the request, the code is as follows (for):

2. ///////////////////////////////////////////
4. //filename: Server.cpp
6. #include <stdio.h>
8. #include <STARCORBA.h>
10. #include <STARCosNaming.h>
12. #include <stdlib.h>
14. #include <errno.h>
16. #include \ "Apptest_impl.h\"
18. using namespace Std;
22. int Main (int argc, Char* argv[], char*[]) {
24. Corba::orb_var ORB;
26. Orb = Corba::orb_init (argc, argv);
30. Corba::object_var nameobj =
32. Orb-> resolve_initial_references (\ "Nameservice\");
34. Cosnaming::namingcontext_var NC =
36. Cosnaming::namingcontext:: _narrow (Nameobj.in ());
40. Corba::object_var poaobj =
42. Orb-> resolve_initial_references (\ "Rootpoa\");
44. Portableserver::P Oa_var Rootpoa =
46. Portableserver::POA:: _narrow (Poaobj);
48. Portableserver::P Oamanager_var manager =
50. Rootpoa-> The_poamanager ();
54. a_impl* Aimpl = new A_impl ();
56. Portableserver::servantbase_var Servanta = Aimpl;
58. Portableserver::objectid_var Aid =
60. Rootpoa-> Activate_object (Servanta);
62. Corba::object_var A =
64. Rootpoa-> servant_to_reference (Servanta);
68. Cosnaming::Name aname;
70. Aname. length (1);
72. Aname[0].id = corba::string_dup (\ "A\");
74. Aname[0].kind = corba::string_dup (\ "Operationa\");
76. NC-> rebind (aname, a.in ());
80. Manager-> activate ();
82. Orb-> Run ();
86. NC-> Unbind (aname);
88. return exit_success;
90. }

　　 Web Application Implementation
In Web applications, CORBA service objects are accessed and displayed through a JSP, which serves as the client side of CORBA. Implementing a Web application requires two tasks: mapping IDL to Java, sending requests in a JSP, and displaying the results.
1. Mapping IDL to Java
This requires only the IDL compiler IDLJ to invoke the JDK, and execute the following command:
IDLJ Apptest.idl
This command will produce five files: A.java, Aoperations.java, Ahelper.java, Aholder.java, and _astub.java, which contains stubs.

2. Send the request in the JSP and show the result.
To avoid having too many script in the JSP, the code that sends the request is separated from the JSP into a simple Java class.
The code for the Java class is as follows (Aclient.java):

2. /*
4. * Aclient.java
6.  */
8. Package example;
12. import org.omg.corba.*;
14. Import org.omg.CORBA.ORBPackage. Invalidname;
16. import org.omg.cosnaming.*;
18. Import org.omg.CosNaming.NamingContextPackage. Cannotproceed;
20. Import org.omg.CosNaming.NamingContextPackage. NotFound;
24. /**
26. * @author the public fly
28.  */
30. Public class aclient {
32. Public Static int OpA (int num) throws Exception {
34. String [] args = { \ "-orbinitref\",
36. \ "Nameservice=corbaloc:iiop:192.168.60.158:900/nameservice\" };
38. Orb orb = orb. Init (args, null);
40. Org.omg.CORBA. Object ObjRef;
42. ObjRef = orb.resolve_initial_references (\ "Nameservice\");
44. namingcontext ncref = namingcontexthelper. Narrow (OBJREF);
46. namecomponent NC = new namecomponent(\ "A\", \ "Operationa\");
48. namecomponent path[] = {NC};
52. Org.omg.CORBA. Object Obja;
54. Obja = ncref.resolve (path);
56. A A = Ahelper.narrow (Obja);
60. int out;
62. out = A.aoperation (num);
64. return out;
66. }
68. }

The code for the JSP file is as follows (index.jsp):

1. <%@ page contenttype=\ "Text/html;charset=gb2312\"%>
2. <%@ page Import = \ "Example. Aclient\ " %>
5. <title>hello JSP CORBA client</title>
7. <body>
8. 3*2=<%=aclient.opa (3)%>
9. </body>

Well, compile your program, run the name service, run the CORBA service program, run the application server Inforweb, deploy the Web application, and then you can access it through the browser.