спецификации, руководства, описания, API

Getting Started with Java IDL: Using Stringified Object References

To invoke an operation on a CORBA object, a client application needs a reference to the object. You can get such references in a number of ways, such as calling ORB.resolve_initial_references() or using another CORBA object (like the name service). In previous sections of this tutorial, you used both of these methods to get an initial object reference.

Often, however, there is no naming service available in the distributed environment. In that situation, CORBA clients use a stringified object reference to find their first object.

In this lesson, you will learn how to create a stringified object reference as a part of the server startup, and how the client gets that reference and destringifies it for use as a real object reference.

The steps in this lesson are:

Making a Stringified Object Reference
Getting a Stringified Object Reference
Destringifying the Object Reference
Compiling and Running a Stringified Hello World

To see completed versions of the source code, follow the links to HelloServer.java and HelloClient.java.

Making a Stringified Object Reference

For a stringified object reference to be available to the client, the server must create it and store it somewhere that the client can access. Your reference will be written to disk in the form of a text file.

Create a new directory at the same level as the Hello directory named HelloString. Copy Hello.idl to this directory.
Copy HelloServer.java from the Hello directory to the HelloString directory. Name it HelloServerString.java, and make the following changes in this file.
Because the new server will write a file to disk, you need to add an import statement. Add the following:
```
import java.io.*; // needed for output to the file system.
```

The new server won't use the naming service, so you don't need the CosNaming packages. Delete these lines from the code:

import org.omg.CosNaming.*;                       // not needed for stringified version
import org.omg.CosNaming.NamingContextPackage.*;  // remove from code

Delete the code that gets the initial naming context and resolves the reference to a Hello object:

      // Get the root naming context
      org.omg.CORBA.Object objRef = orb.resolve_initial_references("NameService");
      NamingContext ncRef = NamingContextHelper.narrow(objRef);
      
      // Bind the object reference in naming
      NameComponent nc = new NameComponent("Hello", " ");
      NameComponent path[] = {nc};
      ncRef.rebind(path, helloRef);

Call the ORB's object_to_string() method and pass it the reference to the servant object. This returns the object reference in a string form that can be saved in a file on disk.
```
      String ior = orb.object_to_string(helloRef);
```

Build the path to the file that will be stored, using system properties to determine the path structure and syntax.

      String filename = System.getProperty("user.home")+
            System.getProperty("file.separator")+"HelloIOR";

Use standard Java operations to write the stringified ior to disk:

      FileOutputStream fos = new FileOutputStream(filename);
      PrintStream ps = new PrintStream(fos);
      ps.print(ior);
      ps.close();

Save and close HelloServerString.java.

When HelloServerString runs, instead of calling the ORB and registering the servant object with naming, it creates the text file HelloIOR containing a stringified reference to the servant. The file is stored in your home directory.

Getting a Stringified Object Reference

Note to Windows users: You should substitute backslashes (\) for the slashes (/) in all paths in this document.

Copy HelloClient.java from the Hello directory to the HelloString directory. Name it HelloClientString.java, and make the following changes in this file.
Because the new client will read a file from the disk, you need to change the import statements. Add the following:
```
import java.io.*; // needed for input from the file system.
```
The new client won't use the naming service, so you don't need the CosNaming package. Delete this line from the code:
```
import org.omg.CosNaming;*  // not needed for stringified version
```

Delete the code that gets the initial naming context and registers the servant with the naming service:

      // Get the root naming context
      org.omg.CORBA.Object objRef = orb.resolve_initial_references("NameService");
      NamingContext ncRef = NamingContextHelper.narrow(objRef);
      
      // Resolve the object reference in naming
      NameComponent nc = new NameComponent("Hello", " ");
      NameComponent path[] = {nc};
      Hello helloRef = HelloHelper.narrow(ncRef.resolve(path));

Use standard Java operations to read the file that has the object reference. Note that client and server programs must know the name of the file and where it is stored.

      String filename = System.getProperty("user.home")+
            System.getProperty("file.separator")+"HelloIOR";
      FileInputStream fis = new FileInputStream(filename);
      DataInputStream dis = new DataInputStream(fis);
      String ior = dis.readLine();

The HelloClientString application now has a String object containing the stringified object reference.

Destringifying the Object Reference

To destringify the object reference in ior, call the standard ORB method:

      org.omg.CORBA.Object obj = orb.string_to_object(ior);

Finally, narrow the CORBA object to its proper type, so that the client can invoke on it:

      Hello helloRef = HelloHelper.narrow(obj);

The rest of the client code stays the same. Save and close HelloClientString.java.

Compiling and Running a Stringified Hello World

Compiling and running the new version of Hello World requires most of the same steps as for the naming service version.

Compiling Hello World

Change to the HelloString directory.
Compile the IDL file. Enter the compiler command:
```
   
	idlj -fall Hello.idl
```
Run the Java compiler on your source code:
```
javac *.java
```
Correct any errors in your files and recompile if necessary. (You can copy the files from HelloServer.java and HelloClient.java if you have trouble finding any typographical errors.)

HelloServerString.class, HelloServantString.class, and HelloClientString.class are generated to the HelloString directory.

Running Hello World

To be certain that you are running your own server, check that all Hello server and name server processes have been stopped. Stop them if they are running.

From an MS-DOS system prompt (Windows) or command shell (UNIX), start the Hello server with the stringified object reference:
```
java HelloServerString -ORBInitialPort 1050 &
```
From another prompt or shell, run the Hello application client with the stringified object reference:
```
java HelloClientString  -ORBInitialPort 1050 &
```
The client prints the string from the server to the command line:
```
Hello world!!
```

For More Information

Initialization: Obtaining Initial Object References: Explains the various ways of getting an initial object reference

Developing the Hello World Server

Developing the Client Application
Tutorial home | HelloClient.java | HelloServer.java

Home