Java IDL: 「Hello World」의 예 - xrath.com 에서 번역됨

# Java IDL: 「Hello World」의 예

## POA,지속서버, 및 지속 네임 서비스의 사용

이 문서는, 인터페이스를 정의하는 IDL (Interface Definiton Language)와 Stub 및 스켈리턴을 생성하는 Java IDL 컴파일러를 사용해, 완전한 CORBA (Common Object Request Broker Architecture) 어플리케이션을 작성하는 방법에 대해, 고레벨의 개요를 설명한 것입니다. 개발 프로세스와 IDL 를 사용해 CORBA 어플리케이션을 작성하는 튜토리얼의 자세한 것은,「Java IDL 입문:「Hello World」의 튜토리얼을 참조해 주세요. 또, Java 프로그램 언어로 인터페이스를 정의해 CORBA 어플리케이션을 작성할 수도 있습니다. 이 개발 프로세스의 상세와 튜토리얼에 대해서는,Java RMI-IIOP 문서를 참조해 주세요.

일시 서버와 지속 서버의 비교의 상세한 것에 대하여는,「서버의 개발」을 참조해 주세요.

이 문서에서는, 다음의 내용에 대해 설명합니다.

- 단순한 「Hello World」프로그램의 IDL
- 객체를 작성해, 디폴트의 서버측 구현 (POA)을 사용하는 네임 서비스와 함께 객체를 발행하는 지속 서버
- 각 IDL 인터페이스를 구현하는「서번트」
- 기존의 객체명의 객체 참조를 네이밍 서비스로부터 찾아, 그 객체를 호출하는어플리케이션 클라이언트
- 컴파일 방법과 실행 방법에 대한설명 례

## 인터페이스의 정의 (`PersistentHello.idl`)

CORBA 어플리케이션 작성의 제일 단계는, OMG 의 인터페이스 정의 언어 (IDL)를 사용해, 객체와 인터페이스를 모두 기술하는 것입니다. IDL 에는 C++ 를 닮은 구문이 있어, 이것을 사용해 모듈, 인터페이스, 데이터 구조등을 정의할 수가 있습니다. IDL 는 다양한 프로그램 언어에 매핑 할 수 있습니다. IDL 를 Java 에 매핑 하는 방법은「IDL 와 Java 언어의 매핑의 개요」 로 설명하고 있습니다.

다음의 코드는 OMG IDL 로 기술된 것으로, CORBA 객체의 `sayHello()` 오퍼레이션이 캐릭터 라인 (string)을 반환 `shutdown()` 메소드가 ORB 를 지 그런데 있습니다. OMG IDL 의 구문과 시멘틱스의 자세한 것은, OMG 의 Web 사이트에서 CORBA Specification 의 제 3 장을 참조해 주세요.

PersistentHello.idl

    module Persistent {
        interface Hello {
            string sayHello( );
            oneway void shutdown();
        };
    };

주: OMG IDL 로 코드를 기술하는 경우, 모듈명에 인터페이스명을 사용하지 말아 주세요. 모듈명에 인스턴스명을 사용하면(자), 다른 벤더의 툴을 사용한 컴파일 실행시에, 결과의 무결성이 유지되지 않게 되는 위험이 있습니다. 그 결과, 코드의 이식성이 손상됩니다. 예를 들어, 같은 이름을 포함한 코드를 Sun Microsystems 의 IDL-to-Java 컴파일러를 사용해 컴파일 하면(자), 1 개의 결과를 얻을 수 있습니다. 같은 코드를 다른 벤더의 IDL-to-Java 컴파일러를 사용해 컴파일 하면(자), 다른 결과가 되는 경우가 있습니다.

어플리케이션을 완성 지난에는, 서버 (`PersistentServer.java`), 서번트 (`PersistentHelloServant.java`), 및 클라이언트 (`PersistentClient.java`)를 구현합니다.

## 서버의 구현 (`PersistentServer.java`)

이 서버예 (`PersistentServer`)에는 서버의 `main()` 메소드가 포함됩니다. 이 `main()` 메소드에서는, 다음의 처리를 실시합니다.

- ORB 의 인스턴스를 생성해 초기화한다
- 서번트를 작성한다
- 루트 POA 에의 참조를 취득한다
- 서버를 지속 서버로 하는 정책를 작성한다
- 지속 정책내에서 건네주는 것에 의해 지속 POA 를 작성한다
- 지속 POA 의 `POAManager` 를 기동한다
- 서번트를 지속 POA 에 관련짓는다
- 루트 네이밍 문맥의 CORBA 객체 참조를 취득해, 새로운 CORBA 객체를 등록한다
- 객체 참조를 네이밍 문맥에 네로우 변환한다
- 새로운 객체를 「PersistentServerTutorial」라고 하는 이름으로 네이밍 문맥에 등록한다
- 클라이언트로부터 새로운 객체가 불려 가는 것을 기다린다

이 예에서는, 지속 객체 서버의 예를 나타냅니다. 일시 객체 서버를 사용하는 「Hello World」프로그램의 예에 대해서는,「일시 서버를 사용한 Hello World 의 예」 를 참조해 주세요. CORBA 서버의 상세한 것에 대하여는,「서버의 개발」을 참조해 주세요.

PersistentServer.java

    // PersistentServer.java
    // Copyright and License
    import java.util.Properties;
    import org.omg.CORBA.Object;
    import org.omg.CORBA.ORB;
    import org.omg.CosNaming.NameComponent;
    import org.omg.CosNaming.NamingContextExt;
    import org.omg.CosNaming.NamingContextExtHelper;
    import org.omg.CORBA.Policy;
    import org.omg.PortableServer.POA;
    import org.omg.PortableServer. *;
    import org.omg.PortableServer.Servant;

    public class PersistentServer {

        public static void main( String args[] ) {
            Properties properties = System.getProperties();
            properties.put( "org.omg.CORBA.ORBInitialHost",
                "localhost" );
            properties.put( "org.omg.CORBA.ORBInitialPort",
                "1050" );

            try {
                // Step 1: Instantiate the ORB
                ORB orb = ORB.init(args, properties);

                // Step 2: Instantiate the servant
                PersistentHelloServant servant = new PersistentHelloServant(orb);

                // Step 3 : Create a POA with Persistent Policy
                // *******************
                // Step 3-1: Get the rootPOA
                POA rootPOA = POAHelper.narrow(orb.resolve_initial_references("RootPOA"));
                // Step 3-2: Create the Persistent Policy
                Policy[] persistentPolicy = new Policy[1];
                persistentPolicy[0] = rootPOA.create_lifespan_policy(
                    LifespanPolicyValue.PERSISTENT);
                // Step 3-3: Create a POA by passing the Persistent Policy
                POA persistentPOA = rootPOA.create_POA("childPOA", null,
                    persistentPolicy );
                // Step 3-4: Activate PersistentPOA's POAManager, Without this
                // All calls to Persistent Server will hang because POAManager
                // will be in the 'HOLD' state.
                persistentPOA.the_POAManager(). activate( );
                // ***********************

                // Step 4: Associate the servant with PersistentPOA
                persistentPOA.activate_object( servant );

                // Step 5: Resolve RootNaming context and bind a name for the
                // servant.
                // NOTE: If the Server is persistent in nature then using Persistent
                // Name Service is a good choice.  Even if ORBD is restarted the Name
                // Bindings will be intact.  To use Persistent Name Service use
                // 'NameService' as the key for resolve_initial_references() when
                // ORBD is running.
                org.omg.CORBA.Object obj = orb.resolve_initial_references(
                    "NameService" );
                NamingContextExt rootContext = NamingContextExtHelper.narrow( obj );

                NameComponent[] nc = rootContext.to_name(
                    "PersistentServerTutorial" );
                rootContext.rebind( nc, persistentPOA.servant_to_reference(
                    servant ) );

                // Step 6: We are ready to receive client requests
                orb.run();
            } catch ( Exception e ) {
                System.err.println( "Exception in Persistent Server Startup " + e );
            }
        }
    }

## 서번트의 구현 (`PersistentHelloServant.java`)

서번트예 `PersistentHelloServant` 는, IDL 인터페이스 `Hello` 의 구현입니다. 즉,`Hello` 의 각 인스턴스는, `PersistentHelloServant` 의 인스턴스에 의해 구현됩니다. 이 서번트는 `HelloPOA` 의 서브 클래스에서, 예제 IDL 로부터 `idlj` 컴파일러에 의해 생성됩니다. 서번트에게는, IDL 의 오퍼레이션 마다 1 개의 메소드가 포함됩니다. 이 예에서는 `sayHello()` 메소드와 `shutdown()` 메소드가 포함됩니다. 서번트 메소드는, Java 의 일반적으로의 메소드와 다르지 않습니다. ORB 관련 처리를 실시하는 코드는 인수나 결과의 정렬화등을 실시해, 스켈리턴으로 제공됩니다.

PersistentHelloServant.java

    // PersistentHelloServant.java
    // Copyright and License
    import org.omg.CORBA.ORB;

    public class PersistentHelloServant extends Persistent.HelloPOA {
        private ORB orb;

        public PersistentHelloServant( ORB orb ) {
            this.orb = orb;
        }

        /**
         *  sayHello() method implementation returns a simple message.
         */
        public String sayHello( ) {
            return "Hello From Persistent Server...";
        }

        /**
         *  shutdown() method shuts down the Persistent Server.
         *  See NOTE below.
         */
        public void shutdown( ) {
            orb.shutdown( false );
        }
    }

주: 이 예에서는, 설명을 위해서(때문에),`shutdown()` 메소드를 서번트의 일부로서 포함하고 있습니다. 이 메소드가 포함되는 것은, 이 예의 서버의 지속성을 나타내기 (위해)때문에입니다. 이 방법은, 다음의 이유에 의해, 프로그래밍 방법으로서는 추천 되지 않습니다.

- 원격 메소드의 구현내에서,`true` 파라미터 ( 「완료를 기다린다」일을 나타낸다)를 지정해 `orb.shutdown()` 메소드를 호출하면(자), ORB 가 데드락을 일으켜 행업 합니다. 다른 thread는, 데드락을 일으키지 않고 `orb.shutdown()` 를 기동할 수 있습니다.
- 복수의 서번트가 ORB 에 관련지을 수 있고 있는 경우, 몇개의 서번트가 `shutdown(false)` 메소드를 사용하면(자), 모든 서번트가 이용할 수 없게 됩니다.
- `orb.shutdown(false)` 메소드는, 충분히 제어된 상황으로, SERVER 코드의 일부로서 호출할 필요가 있습니다.

## 클라이언트 어플리케이션의 구현 (`PersistentClient.java`)

이 어플리케이션 클라이언트에서는, 다음의 처리를 실시합니다.

- ORB 를 생성해 초기화한다
- Interoperable Naming Service (INS)의 `corbaname url` 를 사용해,`PersistentHelloServant` 를 해결한다. URL 는, 호스트 localhost 상에서 실행되어 포트 1050 상에서 대기하고 있는 네임 서비스의 위치를 나타낸다. 이 URL 는, 지정되면(자), 그 네임 서비스로부터 「PersistentServerTutorial」를 해결한다
- 객체의 `sayHello()` 및 `shutdown()` 오퍼레이션을 호출해, 결과를 출력한다. 이 예에서는, 클라이언트는 3 초간에 1 번 `sayHello()` 메소드를 호출해, 서버지 한다. 서버의 지속 라이프 타임을 위해서(때문에), 클라이언트로부터의 다음의 호출에 의해, 서버가 재기동된다

PersistentClient.java

    // Copyright and License

    import java.util.Properties;
    import org.omg.CORBA.ORB;
    import org.omg.CORBA.OBJ_ADAPTER;
    import org.omg.CosNaming.NamingContext;
    import org.omg.CosNaming.NamingContextHelper;
    import org.omg.CosNaming.NameComponent;
    import org.omg.PortableServer.POA;

    import Persistent.HelloHelper;
    import Persistent.Hello;

    public class PersistentClient {

        public static void main(String args[]) {

            try {
                // Step 1: Instantiate the ORB
                ORB orb = ORB.init(args, null);

                // Step 2: Resolve the PersistentHelloServant by using INS's
                // corbaname url.  The URL locates the NameService running on
                // localhost and listening on 1050 and resolve
                // 'PersistentServerTutorial' from that NameService
                org.omg.CORBA.Object obj = orb.string_to_object(
                    "corbaname::localhost:1050#PersistentServerTutorial");

                Hello hello = HelloHelper.narrow( obj );

                // Step 3: Call the sayHello() method every 60 seconds and shutdown
                // the server.  Next call from the client will restart the server,
                // because it is persistent in nature.
                while( true ) {
                    System.out.println( "Calling Persistent Server.." );
                    String helloFromServer = hello.sayHello();
                    System.out.println("Message From Persistent Server: " +
                        helloFromServer );
                    System.out.println( "Shutting down Persistent Server.." );
                    hello.shutdown( );
                    Thread.sleep( 60000 );
                }
            } catch ( Exception e ) {
                System.err.println( "Exception in PersistentClient.java..." + e );
                e.printStackTrace( );
            }
        }
    }

## 「Hello World」의 구축 방법과 실행 방법

「Hello World」프로그램은 단순합니다만, 이 프로그램을 통해,「정적 호출」을 사용하는 CORBA 프로그램의 개발에 필요한 작업 모든 것을 배워, 경험할 수가 있습니다.

이 예에서는 네임 서비스가 필요합니다. 네임 서비스란, 객체 참조에 이름을 바인드 해 CORBA 객체 에 명명할 수가 있는 CORBA 서비스입니다. 「네임 바인딩」 은 네임 서비스에 포함되어 클라이언트는 이름을 주어 목적의 객체 참조를 취득할 수 있습니다. 이 예에서는, 지속 네임 서비스와 서버 매니저를 포함한 orbd 를 사용합니다.

이 예를 실행하기에 즈음해, Solaris 소프트웨어의 사용시는, 포트 1024 미만으로 프로세스를 개시하는 경우, root 사용자가 될 필요가 있습니다. 이 때문에, 1024 이상의 포트를 사용하는 것을 추천합니다. 이하의 설명에서는,`-ORBInitialPort` 옵션을 사용해, Java IDL Object Request Broker Daemon (`orbd`)용으로 포트 1050 을 사용하도록(듯이) 설정할 수 있는 것을 전제로 하고 있습니다. 필요하면 다른 포트로 변경해 주세요.

개발 머신으로 이 클라이언트서버 어플리케이션을 실행하려면 , 다음과 같이 합니다.

1. 이 예의 IDL 파일과 Java 파일을 작성하는지,다운로드합니다.
2. `PersistentHello.idl` 파일이 놓여져 있는 디렉토리로 이동합니다.

3. IDL 파일로부터 IDL-to-Java 컴파일러 `idlj` 를 실행해, Stub와 스켈리턴을 작성합니다. 이 순서는,`java/bin` 디렉토리의 패스를, 사용하는 패스에 포함하고 있는 것을 전제로 하고 있습니다.

         idlj  -fall -td .  -verbose  PersistentHello.idl

   `idlj` 컴파일러의 `-fall` 옵션을 사용해, 클라이언트와 서버측의 바인딩의 양쪽 모두를 생성할 필요가 있습니다. 이 커멘드행으로 디폴트의 서버측 바인딩이 생성됩니다. 이것은 POA 상속 서버측 모델인 것을 전제로 하고 있습니다. `idlj` 옵션의 상세한 것에 대하여는,「IDL-to-Java 컴파일러의 옵션」 을 참조해 주세요.

   `idlj` 컴파일러에서는 다수의 파일이 생성됩니다. 실제로 생성되는 파일의 수는, IDL 파일의 컴파일시에 선택된 옵션에 따라서 다릅니다. 생성된 파일에는 표준의 기능이 있으므로, 프로그램을 배치해 실행할 때까지는 무시해도 괜찮습니다. `PersistentHello.idl` 의 `idlj` 컴파일러로, 커멘드행의 `-fall` 옵션을 사용해 생성되는 파일은 다음과 같습니다.

   - `HelloPOA.java`

     이 추상 클래스는, 스트림 베이스의서버 스켈리턴 으로, 서버용으로 기본적인 CORBA 기능을 제공합니다. 이것은 org.omg.PortableServer.Servant 를 상속해,`InvokeHandler` 인터페이스와 `HelloOperations` 인터페이스를 구현합니다. 서버 클래스 `PersistentHelloServant` 는 `HelloPOA` 를 상속합니다.

   - `_HelloStub.java`

     이 클래스는「클라이언트 Stub」 로, 클라이언트용으로 기본적인 CORBA 기능을 제공합니다. 이것은 `org.omg.CORBA.portable.ObjectImpl` 를 상속해,`Hello` 인터페이스를 구현합니다.

   - `Hello.java`

     이 인터페이스에는 작성한 IDL 인터페이스의 Java 판이 포함됩니다. Hello.java 인터페이스는 표준적인 CORBA 객체 기능을 주는 `org.omg.CORBA.Object` 인터페이스를 상속합니다. 또 `HelloOperations` 인터페이스 및 `org.omg.CORBA.portable.IDLEntity` 도 상속합니다.

   - `HelloHelper.java`

     이 클래스는 보조 기능, 특히 CORBA 객체 참조 를 적절한 형태에 캐스트 하는 `narrow()` 메소드를 제공합니다. Helper 클래스는 CORBA 스트림에의 데이터형의 입출력과`Any` 의 데이터형의 삽입과 추출을 취급합니다. Holder 클래스는, Helper 클래스의 메소드에 입출력을 위양 합니다.

   - `HelloHolder.java`

     HelloHolder.java 이 `final` 클래스에는,`Hello` 형의 퍼블릭 인스턴스 멤버가 들어옵니다. IDL 형의 파라미터가 `out` 또는 `inout` 이면 Holder 클래스가 사용됩니다. 여기에서는,`org.omg.CORBA.portable.OutputStream` 및 `org.omg.CORBA.portable.InputStream` 인수에 대한 오퍼레이션이 규정됩니다. 이러한 인수는 CORBA 에는 존재합니다만, Java 의 시멘틱스에는 간단하게 매핑 할 수 없습니다. Holder 클래스는 Helper 클래스의 메소드에 입출력을 위양 합니다. Holder 클래스는 `org.omg.CORBA.portable.Streamable` 를 구현합니다.

   - `HelloOperations.java`

     이 인터페이스에는 `sayHello()` 메소드 및 `shutdown()` 메소드가 포함됩니다. IDL-to-Java 매핑은, IDL 인터페이스로 정의된 오퍼레이션을 모두 이 파일에 짜넣어, Stub와 스켈리턴으로 공유합니다.

4. `Persistent` 디렉토리에 있는 Stub와 스켈리턴도 포함해`. java` 파일을 컴파일 합니다. 이 순서는,`java/bin` 디렉토리가 실행 패스에 포함되어 있는 것을 전제로 하고 있습니다.

          javac *. java Persistent/*.java

5. `orbd` 를 기동합니다.

   `orbd` 를 기동하려면 , 다음의 커멘드를 입력합니다.

         orbd -ORBInitialPort 1050 -serverPollingTime 200&          (UNIX  operating system)

         start orbd  -ORBInitialPort 1050 -serverPollingTime 200&   (Windows  operating system)

   `1050` 은 네임서버-를 실행하는 포트입니다. `-ORBInitialPort` 는 필요한 커멘드행의 인수입니다. Solaris 소프트웨어의 사용시는, 1024 보다 작은 포트로 프로세스를 개시하는 경우는, root 사용자가 될 필요가 있습니다. 이 때문에, 1024 이상의 포트를 사용하는 것을 추천합니다.

   `-serverPollingTime 200` 인수는,`servertool` 를 사용해 등록된 지속 서버가 정상적으로 동작하고 있는 것을 ORBD 가 확인하는 회수를 지정합니다. 디폴트 값는 1,000 밀리 세컨드입니다. 이 예에서는, 빈번하게 장해를 감시할 수 있도록(듯이), 이 파라미터를 200 밀리 세컨드로 설정합니다. 서버의 장해가 검출되었을 경우는, 적절한 상태가 되도록(듯이) 서버가 재기동됩니다.

6. Hello 서버를 기동합니다.

   지속 서버를 ORBD 에 등록하려면 ,servertool 를 사용해 서버를 기동할 필요가 있습니다. servertool 는, 어플리케이션 프로그래머가, 지속 서버의 등록, 등록 해제, 기동, 및 정지를 행하기 위한 커멘드행 인터페이스입니다. `servertool` 를 기동하면(자),`orbd` 가 실행되고 있는 포트와 호스트 (다른 경우)를 지정할 필요가 있습니다.

   Hello 서버를 기동하려면

   - 다음과 같이, 다른 단말 윈도우의 커멘드행 또는 커멘드 prompt로부터 `servertool` 를 기동합니다.

           servertool -ORBInitialPort 1050        (UNIX  operating system)

           start servertool -ORBInitialPort 1050  (Windows  operating system)

     전회의 순서와 같게 네임서버- (`orbd`)의 포트를 지정합니다. 예를 들어 `-ORBInitialPort 1050` 과 같이 됩니다. `servertool` 는, 네임서버-와 같은 포트상에서 기동할 필요가 있습니다.

     `servertool` 커멘드행 인터페이스가 표시됩니다.

   - 다음에 나타내도록(듯이),`servertool` 의 prompt로부터 `PersistentServer` 를 등록합니다. 다음의 정보는, 개행하지 않고 1 개(살)의 긴 캐릭터 라인으로서 입력합니다.

           servertool  > register -server PersistentServer -applicationName s1
                         -classpath path_to_server_class_files

     `servertool` 에 의해 서버가 등록되어, 「s1」라고 하는 이름을 서버에 할당할 수 있어 서버 ID 가 표시됩니다.

7. 다음과 같이, 다른 단말 윈도우의 커멘드행 또는 커멘드 prompt로부터 클라이언트 어플리케이션을 실행합니다.

         java -classpath .  PersistentClient

   단말 윈도우 또는 DOS prompt에 이하의 메세지가 표시됩니다.

       Calling Persistent Server..
       Message From Persistent Server: Hello From Persistent Server...
       Shutting down Persistent Server..
       Calling Persistent Server..
       Message From Persistent Server: Hello From Persistent Server...
       Shutting down Persistent Server..

이 예에서는, 클라이언트가 1 분간에 1 번 `sayHello()` 메소드를 기동해, 지속 서버를 종료합니다. 지속 서버는, 다음에 클라이언트가 `sayHello()` 메소드를 기동했을 때에 자동적으로 재기동됩니다.

이 튜토리얼을 종료하면(자), 네임서버- (`orbd`) 지 하든가 종료해 주세요. DOS prompt에서는, 서버를 실행하고 있는 윈도우를 선택해 `Ctrl+C` 라고 입력하면(자) 정지합니다. UNIX 쉘에서는, 단말 윈도우로부터 `pkill ordb` 라고 입력합니다. 서버를 명시적으로 정지할 때까지는, 호출 대기 상태가 계속됩니다.

「2 대의 머신으로 실행하는 Hello World 프로그램」 에서는, 클라이언트와 서버라고 하는 2 대의 머신으로 간단한 어플리케이션을 분산시키는 방법의 일례를 나타냅니다.

## UNIX 상에서의 Makefile 를 사용한 예의 실행

이하의 코드는, 이 예를 실행하기 위해서 사용할 수 있는 Makefile 의 예를 나타내고 있습니다. JAVA_HOME 의 장소는, 실제로 J2SE 5.0 을 인스톨 한 장소로 변경해 주세요. `CLASSPATH` 변수는, 샘플 어플리케이션을 작성한 디렉토리로 변경해 주세요. 이 예는, UNIX operating system를 상정해 작성되고 있습니다. Windows operating system를 사용하고 있는 경우는, 적당 변경을 더해 주세요.

    #Change to location of your Java SE installation.
    JAVA_HOME=/home/user_name/j2sdk1. 5.0/

    CLASSPATH=.

    JAVAC=$(JAVA_HOME) /bin/javac
    JAVA=$(JAVA_HOME) /bin/java

    ORB_INITIAL_PORT=1050
    ORB_INITIAL_HOST=localhost
    ORB_ACTIVATION_PORT=1049

    #Change ClassPath based on where your PersistentServer is located.
    export CLASSPATH=<path to server class files>
    IDLJ :=$(JAVA_HOME) /bin/idlj

    ORB_PROPS=-Dorg.omg.CORBA.ORBInitialHost=$(ORB_INITIAL_HOST)
    -Dorg.omg.CORBA.ORBInitialPort=$(ORB_INITIAL_PORT)

    IDLJ_FLAGS=-fall -td .  -verbose

    ORBD=${JAVA_HOME}/bin/orbd -ORBInitialPort ${ORB_INITIAL_PORT}
    -port ${ORB_ACTIVATION_PORT} -serverPollingTime 200
    -serverStartupDelay 1000

    SERVERTOOL=${JAVA_HOME}/bin/servertool

    all: clean build run

    build: stubs

    stubs:
    	$(IDLJ) $(IDLJ_FLAGS) PersistentHello.idl
    	$(JAVAC) *. java
    	$(JAVAC) Persistent/*.java

    runc:
    	$(JAVA) -classpath .  PersistentClient

    runorbd:
    	$(ORBD)

    # Enter the following command in servertool to register server:
    # (without the # sign)
    # register -server PersistentServer -applicationName s1
    -classpath path_to_server_class_files

    servertool:
    	$(SERVERTOOL) -ORBInitialPort $(ORB_INITIAL_PORT)

    clean:
    	rm -rf Persistent
    	rm -rf *. class

Makefile 를 사용해 어플리케이션을 실행하려면 , 이하의 커멘드를 입력합니다.

1. gnumake build
2. gnumake runorbd
3. gnumake runservertool
4. `servertool` 로, 상기의 커멘드를 입력합니다.
5. gnumake runc

Java IDL 탑에