Java Language
JNDI

RMI über JNDI

Dieses Beispiel zeigt, wie JNDI in RMI funktioniert. Es hat zwei Rollen:

• Um dem Server eine Bind / Unind / Re-Bind-API für die RMI-Registry bereitzustellen
• Um dem Client eine Lookup / List-API für die RMI-Registry bereitzustellen.

Die RMI-Registry ist Teil von RMI, nicht von JNDI.

Um dies zu java.rmi.registry.CreateRegistry() , verwenden wir java.rmi.registry.CreateRegistry() , um die RMI-Registry zu erstellen.

1. Server.java (der JNDI-Server)

   package com.neohope.jndi.test;
   
   import javax.naming.Context;
   import javax.naming.InitialContext;
   import javax.naming.NamingException;
   import java.io.IOException;
   import java.rmi.RemoteException;
   import java.rmi.registry.LocateRegistry;
   import java.util.Hashtable;
   
   /**
    * JNDI Server
    * 1.create a registry on port 1234
    * 2.bind JNDI
    * 3.wait for connection
    * 4.clean up and end
    */
   public class Server {
       private static Registry registry;
       private static InitialContext ctx;
   
       public static void initJNDI() {
           try {
               registry = LocateRegistry.createRegistry(1234);
               final Hashtable jndiProperties = new Hashtable();
               jndiProperties.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.rmi.registry.RegistryContextFactory");
               jndiProperties.put(Context.PROVIDER_URL, "rmi://localhost:1234");
               ctx = new InitialContext(jndiProperties);
           } catch (NamingException e) {
               e.printStackTrace();
           } catch (RemoteException e) {
               e.printStackTrace();
           }
       }
   
       public static void bindJNDI(String name, Object obj) throws NamingException {
           ctx.bind(name, obj);
       }
   
       public static void unbindJNDI(String name) throws NamingException {
           ctx.unbind(name);
       }
   
       public static void unInitJNDI() throws NamingException {
           ctx.close();
       }
   
       public static void main(String[] args) throws NamingException, IOException {
           initJNDI();
           NMessage msg = new NMessage("Just A Message");
           bindJNDI("/neohope/jndi/test01", msg);
           System.in.read();
           unbindJNDI("/neohope/jndi/test01");
           unInitJNDI();
       }
   }
   

2. Client.java (der JNDI-Client)

   package com.neohope.jndi.test;
   
   import javax.naming.Context;
   import javax.naming.InitialContext;
   import javax.naming.NamingException;
   import java.util.Hashtable;
   
   /**
    * 1.init context
    * 2.lookup registry for the service
    * 3.use the service
    * 4.end
    */
   public class Client {
       public static void main(String[] args) throws NamingException {
           final Hashtable jndiProperties = new Hashtable();
           jndiProperties.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.rmi.registry.RegistryContextFactory");
           jndiProperties.put(Context.PROVIDER_URL, "rmi://localhost:1234");
   
           InitialContext ctx = new InitialContext(jndiProperties);
           NMessage msg = (NeoMessage) ctx.lookup("/neohope/jndi/test01");
           System.out.println(msg.message);
           ctx.close();
       }
   }
   

3. NMessage.java (RMI-Serverklasse)

   package com.neohope.jndi.test;
   
   import java.io.Serializable;
   import java.rmi.Remote;
   
   /**
    * NMessage
    * RMI server class
    * must implements Remote and Serializable 
    */
   public class NMessage implements Remote, Serializable {
       public String message = "";
   
       public NMessage(String message)
       {
           this.message = message;
       }
   }
   

So führen Sie den eaxmple aus:

1. Erstellen und starten Sie den Server
2. Erstellen und starten Sie den Client

Vorstellen

JNDI (Java Naming and Directory Interface) ist eine Java-API für einen Verzeichnisdienst, mit der Java-Software-Clients Daten und Objekte über einen Namen ermitteln und suchen können. Es ist so konzipiert, dass es unabhängig von bestimmten Namens- oder Verzeichnisdienstimplementierungen ist.

Die JNDI-Architektur besteht aus einer API (Application Programming Interface) und einer SPI (Service Provider Interface). Java-Anwendungen verwenden diese API, um auf verschiedene Namens- und Verzeichnisdienste zuzugreifen. Das SPI ermöglicht das transparente Einfügen einer Vielzahl von Namens- und Verzeichnisdiensten, sodass die Java-Anwendung mit Hilfe der API der JNDI-Technologie auf ihre Dienste zugreifen kann.

Wie Sie im obigen Bild sehen können, unterstützt JNDI LDAP, DNS, NIS, NDS, RMI und CORBA. Sie können es natürlich erweitern.

Wie es funktioniert

In diesem Beispiel verwendet Java RMI die JNDI-API, um Objekte in einem Netzwerk nachzuschlagen. Wenn Sie ein Objekt suchen möchten, benötigen Sie mindestens zwei Informationen:

• Wo finde ich das Objekt?

Die RMI-Registry verwaltet die Namensbindungen und gibt an, wo das Objekt zu finden ist.

• Der Name des Objekts

Was ist ein Objektname? Normalerweise handelt es sich um eine Zeichenfolge. Es kann sich auch um ein Objekt handeln, das die Namensschnittstelle implementiert.

Schritt für Schritt

1. Zunächst benötigen Sie eine Registry, die die Namensbindung verwaltet. In diesem Beispiel verwenden wir java.rmi.registry.LocateRegistry .

   //This will start a registry on localhost, port 1234
   registry = LocateRegistry.createRegistry(1234);
   

2. Sowohl Client als auch Server benötigen einen Kontext. Server verwenden den Kontext, um den Namen und das Objekt zu binden. Der Client verwendet den Kontext, um den Namen abzurufen und das Objekt abzurufen.

   //We use com.sun.jndi.rmi.registry.RegistryContextFactory as the InitialContextFactory
   final Hashtable jndiProperties = new Hashtable();
   jndiProperties.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.rmi.registry.RegistryContextFactory");
   //the registry usrl is "rmi://localhost:1234"
   jndiProperties.put(Context.PROVIDER_URL, "rmi://localhost:1234");
   InitialContext ctx = new InitialContext(jndiProperties);
   

3. Der Server bindet den Namen und das Objekt

   //The jndi name is "/neohope/jndi/test01"
   bindJNDI("/neohope/jndi/test01", msg);
   

4. Der Client sucht das Objekt unter dem Namen "/ neohope / jndi / test01".

   //look up the object by name "java:com/neohope/jndi/test01"
   NeoMessage msg = (NeoMessage) ctx.lookup("/neohope/jndi/test01");
   

5. Nun kann der Client das Objekt verwenden

6. Wenn der Server beendet wird, müssen Sie aufräumen.

   ctx.unbind("/neohope/jndi/test01");
   ctx.close();