public interface MyServer extends Remote
 {
   // El cliente se pasa a sí mismo como primer parámetro. El servidor puede llamar a un 
   // método remoto en el cliente. Esto es útil cuando el procesamiento de peticiones toma mucho tiempo.
   void receiveRequest(MyClient client, String message) throws RemoteException;
 }
 
 public interface MyClient extends Remote
 {
   // Este método remoto es llamado por el servidor.
   void receiveReply(String message) throws RemoteException;
 }

 public class MyServerImpl implements MyServer
 {
    void receiveRequest(MyClient client, String message) throws RemoteException
    {
      System.out.println("The client says: "+message);
      client.receiveReply("Yes, "+message+", "+message+", "+message+"...");
    }
 }
 
 public class MyClientImpl implements MyClient
 {
    MyServer server;
    public MyClientImpl(String Server_IOR, ORB orb)
      throws Exception
    {
      server = (MyServer) PortableRemoteObject.narrow(
                  orb.string_to_object(Server_IOR), MyServer.class);
    }
    // Esto es un método remoto.
    void receiveReply(String message) throws RemoteException
    {
      System.out.println("And the answer is: "+message);
    }
    // Esto no es un método remoto, esto es un método local.
    public void talk(String conversation)
    {
       server.receiveRequest(this, conversation);
    }
 }

new Thread()
{
    public void run()
    {
        try
        {
            // Crea el [[CORBA]] ORB.
            MyServerImpl.orb = ORB.init(args, properties);
 
            // Obtiene el [[Adaptador de Objeto Portable]] raíz:
            POA rootPOA = POAHelper.narrow(MyServerImpl.orb.resolve_initial_references("RootPOA"));              
            // MyServerImpl contiene la implementación de 
            // los métodos que nuestro servidor debe soportar.
            MyServerImpl impl = new MyServerImpl();
            PortableRemoteObject.exportObject(impl);
 
            // Construye el lazo uqe es también el [[Servant (CORBA)|Servant]].
            // La clase _MyServerImpl_Tie se genera automáticamente desde MyServerImpl.
            Tie tie = new _MyServerImpl_Tie();    
            // Asigna el objetivo de la invocación para este lazo.
            tie.setTarget(impl);
 
            // Obtiene la referencia al correspondiente objeto CORBA:
            org.omg.CORBA.Object object = rootPOA.servant_to_reference((Servant) tie);
 
            // Activa el POA raíz.
            rootPOA.the_POAManager().activate();
            // Obtiene el IOR URL que debe ser pasado a los clientes.
            String Server_IOR = MyServerImpl.orb.object_to_string(object);
            MyServerImpl.orb.run();
 
            // El contenido el string variable Server_IOR debe ser transferido 
            // a nuestro cliente.
        }
        catch (Exception exc)
        {
            exc.printStackTrace();
        }
    }
}.start();

MyClient the_client;
 
new Thread()
{
    public void run()
    {
        try
        {
            ORB orb = ORB.init(args, parameters);
            the_client = new MyClientImpl(Server_IOR, orb);
            POA rootPOA = POAHelper.narrow(desk.orb.resolve_initial_references("RootPOA"));
            rootPOA.the_POAManager().activate();
            // Construye el lazo.
            Tie tie = new _MyClientImpl_Tie();
            // Asigna la clase implementadora (objetivo de la invocación).
            tie.setTarget(the_client);
            // Conecta el lazo como POA servant.
            org.omg.CORBA.Object object = rootPOA.servant_to_reference((Servant) tie);
            // El valor del string [[Interoperable Object Reference|IOR]] puede usarse para encontrar este objeto en la web
            String IOR = desk.orb.object_to_string(object);
            orb.run();
        }
        catch (Exception exc)
        {
            exc.printStackTrace();
        }
    }
}.start();