W tym punkcie poruszymy ważny temat lokalizacji zasobów w środowiskach rozproszonych. Bardzo dobrze będzie widoczne jego znaczenie przy omawianiu protokołu RMI-IIOP. Ten zaś jest podstawą interakcji w serwerach J2EE.

1. Serwisy nazw i katalogów

2. JNDI - koncepcja i architektura

1. Uruchomienie odpowiedniego serwera nazw, dostarczającego wymaganego serwisu (zazwyczaj)
2. Uzyskanie inicjalnego kontekstu dla tego serwisu (Context ctx = new InitialContext(...))
3. Ew. dodawanie lub wyszukiwanie podkontekstów (przechodzenie do podkontekstów - ctx.lookup(podkontekst))
4. Odnajdywanie zasobu po nazwie (ctx.lookup("NazwaZasobu")) lub wiązanie nazwy z zasobem w danym kontekście (ctx.bind("NazwaZasobu", refDoZasobu) lub ctx.rebind("NazwaZasobu", refDoZasobu)).

• LDAP (LightWeight Directory Access Protocol),
• RMI - (rejestr RMI) 
• CORBA - Common Object Services (COS) name service,
• DNS.

3. JNDI - praktyczne przykłady

• nazwy klasy - fabryki wytwarzającej inicjalny kontekst (inicjalny kontekst będzie obiektem tej klasy),
• URLa dostawcy serwisu (service provider) dla tego inicjalnego kontekstu,

• właściwości aplikacji, dostarczone w pliku jndi.properties,
• właściwości środowiskowe, dostarczone jako tablica asocjacyjna (Hashtable),
• właściwości systemowe, określone jako argumenty wywołania JVM (opcja -D).

Hashtable env = new Hashtable(11);
env.put(Context.INITIAL_CONTEXT_FACTORY,
        "com.sun.jndi.fscontext.RefFSContextFactory");
Context initCtx = new InitialContext(env);

// Metoda lookup pozwala na odnalezienie zasobu:

Object obj = initCtx.lookup("e:/temp");

java.naming.factory.initial=com.sun.jndi.fscontext.RefFSContextFactory

Context initCtx = new InitialContext();  // konstruktor bezparametrowy

// Metoda lookup pozwala na odnalezienie zasobu:

Object obj = initCtx.lookup("e:/temp");

java -Djava.naming.factory.initial=com.sun.jndi.fscontext.RefFSContextFactory Prg

• uruchomić odpowiedni serwer (np. ORB lub JMX), specyfikując host i port na którym działa,
• w programie A zerejestrować zasoby w inicjalnym kontekście właściwym dla danego serwera za pomocą metody ctx.bind("NazwaZasobu") lub ctx.rebind("NazwaZasobu")
• w programie B (który ma mieć dostęp do rozproszonych zasobów) wykonać ctx.lookup("NazwaZasobu")

  DataSource dataSource;  // źrodło danych

  public void init() throws ServletException {
    try {
      Context init = new InitialContext();
      Context contx = (Context) init.lookup("java:comp/env");
      dataSource = (DataSource) contx.lookup("jdbc/ksidb");
     } catch (NamingException exc) {
        throw new ServletException(
          "Nie mogę uzyskać źródła java:comp/env/jdbc/ksidb", exc);
     }
  }

  <Resource name="jdbc/ksidb" auth="Container"
            type="javax.sql.DataSource"
            description="Baza danych ksiazek"
            driverClassName="com.mysql.jdbc.Driver"
            url="jdbc:mysql://localhost/ksidb"
            username="admin"
            password="admin"
            maxActive="20" />

    <env-entry>
      <description>Maksymalna temperatura</description>
      <env-entry-name>maxTemp</env-entry-name>
      <env-entry-type>java.lang.Integer</env-entry-type>
      <env-entry-value>37</env-entry-value>
    </env-entry>

InitialContext iniCtx = new InitialContext();
Context envCtx = (Context) iniCtx.lookup("java:comp/env");
Integer maxExemptions = (Integer) envCtx.lookup("maxTemp");

4. Zdalne wywołanie metod - RMI-IIOP

• marshalling/unmarshalling (szeregowanie/rozszeregowanie) - operacje konieczne, by argument wywołania zdalnej metody był w środowisku zdalnej metody właściwie zinterpretowany (np. jak uzyskać dostęp do obiektu, gdy do innej JVM przekazywana jest referencja do niego - jako argument zdalnego wywołania - a sam obiekt na tej zdalnej JVM nie istnieje)
• uwzględnienie niestabilności sieciowych  -  aplikacja rozproszona musi być przygotowana na niestabilności sieciowe.

1. Wywołania metod na rzecz obiektów zdalnych odbywają się wyłącznie w kategoriach interfejsów. Czyli klasa naszego zdalnego obiektu musi koniecznie implementować interfejs, w którym wyszczególnione zostały zdalne metody.
2. Ten interfejs musi rozszerzać interfejs java.rmi.Remote.
3. Metody tego interfejsu winny być deklarowane jako zgłaszające wyjątek java.rmi.RemoteException (ponieważ przy ich zdalnym wywołaniu może nastąpić jakiś błąd komunikacji sieciowej, skutkujący powstaniem właśnie takiego wyjątku).
4. Klasa zdalnego obiektu oprócz implementacji zdalnego interfejsu winna "eksportować" zdalny obiekt - czyli uczynić go zdolnym do przyjmowania "zleceń" - zdalnych wywołań metod. Można to zrobić poprzez    odziedziczenie klasy  javax.rmi.PortableRemoteObject (zapewniając  aby przy tworzeniu jej obiektów był wywoływany konstruktor nadklasy) albo  eksportować zdalny obiekt za pomocą statycznej metody exportObject() z klasy PortableRemoteObject. Eksportowanie obiektu oznacza jego interakcję z usługami sieciowego, dlatego zarówno wywołanie (jawne lub niejawne) konstruktora nadklasy jak i exportObject może - np. w przypadku awarii sieci - powodować powstanie wyjątku RemoteException. Dlatego sygnatura konstruktora klasy zdalnej musi uwzględniać ten wyjątek.

import java.rmi.*;
import javax.rmi.*;

// Interfejs

public interface AddressInfoInterface extends Remote {

   public String getAddress(String name) throws RemoteException;

}

// Implementacja

public class AddressInfo extends PortableRemoteObject
                         implements AddressInfoInterface {

   public AddressInfo(....)  throws RemoteException {
     super();  // będzie wołany automatycznie, ale specjalnie zaznaczam!
     //.....
   }

   public String getAddress(String name) throws RemoteException {
     // ...
   }
}

import javax.naming.*;

public class AddressInfoServer {

    public static void main(String[] args) {
        try {
            // Utworzenie zdalnego obiektu
            AddressInfo ref =
                  new AddressInfo(...);

            // Rejestracja obiektu w serwisie nazw pod nazwą
            // AddressInfoService
            // Uwaga: konkretny inicjalny kontekst określą właściwości systemowe

            Context ctx = new InitialContext();
            ctx.rebind("AddressInfoService", ref );

         } catch (Exception exc) {
            e.printStackTrace();
         }
     }
}

• odszukania obiektu za pomocą JNDI (od serwera nazw dostaniemy referencję typu Object),
• dokonania zawężającej konwersji do typu interfejsu zdalnego obiektu - za pomocą specjalnej metody klasy PortableRemoteObject

import javax.rmi.*;
import javax.naming.*;

public class AddressInfoClient {

    public static void  main( String args[] ) {

        try {
            Context ctx = new InitialContext();

            Object objref = ctx.lookup("AddressInfoService");

            AddressInfoInterface aif; // uwaga: zawsze interfejs!
            aif = (AddressInfoInterface) PortableRemoteObject.narrow(
                                   objref, AddressInfoInterface.class);

        // zdalne wywolanie metod
        String name = "Kowalski Jan";
        String adres = aif.getAddress(name);
        System.out.println(name + " - adres: " + adres);


        } catch( Exception e ) {
            e.printStackTrace( );
        }
    }
}

5. RMI-IIOP od środka

            Object objref = ctx.lookup("AddressInfoService");
            System.out.println(objref.getClass().getName());

import java.rmi.RemoteException;
import java.rmi.UnexpectedException;
import javax.rmi.CORBA.Stub;
import javax.rmi.CORBA.Util;
import org.omg.CORBA.SystemException;
import org.omg.CORBA.portable.ApplicationException;
import org.omg.CORBA.portable.InputStream;
import org.omg.CORBA.portable.ObjectImpl;
import org.omg.CORBA.portable.RemarshalException;
import org.omg.CORBA.portable.ServantObject;
import org.omg.CORBA_2_3.portable.OutputStream;

public class _AddressInfoInterface_Stub extends Stub
    implements AddressInfoInterface
{

    public _AddressInfoInterface_Stub()
    {
    }

    public String[] _ids()
    {
        return _type_ids;
    }

    static Class _mthclass$(String s)
    {
        try
        {
            return Class.forName(s);
        }
        catch(ClassNotFoundException classnotfoundexception)
        {
            throw new NoClassDefFoundError(classnotfoundexception.getMessage());
        }
    }

    public String getAddress(String s)
        throws RemoteException
    {
        if(!Util.isLocal(this))
            try
            {
                org.omg.CORBA_2_3.portable.InputStream inputstream = null;
                try
                {
                    String s2;
                    try
                    {
                        OutputStream outputstream = (OutputStream)_request("getAddress", true);
                        outputstream.write_value(s, java.lang.String.class);
                        inputstream = (org.omg.CORBA_2_3.portable.InputStream)_invoke(outputstream);
                        String s1 = (String)inputstream.read_value(java.lang.String.class);
                        return s1;
                    }
                    catch(ApplicationException applicationexception)
                    {
                        inputstream = (org.omg.CORBA_2_3.portable.InputStream)applicationexception.getInputStream();
                        String s4 = inputstream.read_string();
                        throw new UnexpectedException(s4);
                    }
                    catch(RemarshalException _ex)
                    {
                        s2 = getAddress(s);
                    }
                    return s2;
                }
                finally
                {
                    _releaseReply(inputstream);
                }
            }
            catch(SystemException systemexception)
            {
                throw Util.mapSystemException(systemexception);
            }
        ServantObject servantobject = _servant_preinvoke("getAddress", AddressInfoInterface.class);
        if(servantobject == null)
            return getAddress(s);
        try
        {
            Throwable throwable1;
            try
            {
                String s3 = ((AddressInfoInterface)servantobject.servant).getAddress(s);
                return s3;
            }
            catch(Throwable throwable)
            {
                throwable1 = (Throwable)Util.copyObject(throwable, _orb());
            }
            throw Util.wrapException(throwable1);
        }
        finally
        {
            _servant_postinvoke(servantobject);
        }
    }

    private static final String _type_ids[] = {
        "RMI:AddressInfoInterface:0000000000000000"
    };

}

import java.rmi.Remote;
import javax.rmi.CORBA.Tie;
import org.omg.CORBA.BAD_OPERATION;
import org.omg.CORBA.ORB;
import org.omg.CORBA.Object;
import org.omg.CORBA.SystemException;
import org.omg.CORBA.portable.ResponseHandler;
import org.omg.CORBA.portable.UnknownException;
import org.omg.CORBA_2_3.portable.InputStream;
import org.omg.CORBA_2_3.portable.ObjectImpl;
import org.omg.CORBA_2_3.portable.OutputStream;

public class _AddressInfo_Tie extends ObjectImpl
    implements Tie
{

    public _AddressInfo_Tie()
    {
        target = null;
    }

    public String[] _ids()
    {
        return _type_ids;
    }

    public org.omg.CORBA.portable.OutputStream _invoke(String s, org.omg.CORBA.portable.InputStream inputstream, ResponseHandler responsehandler)
        throws SystemException
    {
        try
        {
            InputStream inputstream1 = (InputStream)inputstream;
            if(s.equals("getAddress"))
            {
                String s1 = (String)inputstream1.read_value(java.lang.String.class);
                String s2 = target.getAddress(s1);
                OutputStream outputstream = (OutputStream)responsehandler.createReply();
                outputstream.write_value(s2, java.lang.String.class);
                return outputstream;
            } else
            {
                throw new BAD_OPERATION();
            }
        }
        catch(SystemException systemexception)
        {
            throw systemexception;
        }
        catch(Throwable throwable)
        {
            throw new UnknownException(throwable);
        }
    }

    public void deactivate()
    {
        _orb().disconnect(this);
        _set_delegate(null);
        target = null;
    }

    public Remote getTarget()
    {
        return target;
    }

    public ORB orb()
    {
        return _orb();
    }

    public void orb(ORB orb1)
    {
        orb1.connect(this);
    }

    public void setTarget(Remote remote)
    {
        target = (AddressInfo)remote;
    }

    public org.omg.CORBA.Object thisObject()
    {
        return this;
    }

    private AddressInfo target;
    private static final String _type_ids[] = {
        "RMI:AddressInfoInterface:0000000000000000"
    };

}

String s2 = target.getAddress(s1);

6. Uruchomienie przykładowej aplikacji

1. Stworzyć interfejs (rozszerzający Remote) i określić metody zdalne (muszą deklarować sygnalizację wyjątku RemoteException)
2. Implementować interfejs w klasie zdalnego obiektu
3. Zapewnić eksport zdalnego obiektu (czy to przez dziedziczenie czy przez użycie metody exportObject w tej czy innej klasie)
4. Skompilować interfejs i  implementację (AddressInfoInterface,java i AddressInfo.java)
5. Użyć rmic z opcją -iiop i argumentem - klasą implementacji do wyprodukowania klas namiastki (powstanie _AddressInfoInterface_Stub.class) i łącznika (powstanie: _AddressInfo_Tie.class)

rmic -iiop AddressInfo

6. Napisać i skompilować "serwer" tworzący i rejestrujący w JNDI zdalny obiekt (zob. poprzedni wydruk AddressInfoServer.java). To tutaj zwykle następuje eksport (przez wywołanie konstruktora lub metody exportObject) no i nadanie nazwy obiektowi.
7. Napisać i skompilować oprogramowanie wywołujące zdalnie metody obiektu (AddressInfoClient).
8. Po stronie serwera umieścić:
• AddressInfo.class
• AddressInfoInterface.class
• _AddressInfoInterface_Stub.class
• _AddressInfo_Tie.class
• AddressInfoServer.class
9. Po stronie klienta umieścić:
• AddressInfoInterface.class
• _AddressInfoInterface_Stub.class
• AddresInfoClient.class
10. Uruchomić serwer ORB (orbd.exe), który m.in. dostarcza serwisu nazw COS naming (jako argument należy podać wybrany port - najlepiej jakiś wysoki numer; można też wyspecyfikowac host, domyślnie mamy localhost)

start orbd -ORBInitialPort 3333

11. Uruchomić serwer, definiując przy tym konfigurację JNDI (kto jest dostarczycielem inicjalnego kontekstu i jak jest dostępny serwer nazw). Możemy tę konfigurację podać w pliku jndi.properties lub jako właściwości systemowe przy uruchamianiu wirtualnej maszyny Javy: java -D... (uwaga: provider to  serwer ORB, zatem i host i port powinien być taki sam jak przy starcie serwera ORB):

java.naming.factory.initial=com.sun.jndi.cosnaming.CNCtxFactory
java.naming.provider.url=iiop://localhost:3333 

12.  Uruchomić klienta, podając taką samą konfigurację JNDI.

7. Zadania