Java Language
JNDI

RMI via JNDI

Dit voorbeeld laat zien hoe JNDI werkt in RMI. Het heeft twee rollen:

• om de server te voorzien van een bind / ontbinden / rebind-API voor het RMI-register
• om de client te voorzien van een opzoek / lijst-API voor het RMI-register.

Het RMI-register maakt deel uit van RMI, niet van JNDI.

Om dit eenvoudig te maken, gebruiken we java.rmi.registry.CreateRegistry() om het RMI-register te maken.

1. Server.java (de 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 (de 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;
       }
   }
   

Hoe de eaxmple uit te voeren:

1. bouw en start de server
2. bouw en start de client

Voorstellen

De Java Naming and Directory Interface (JNDI) is een Java API voor een directoryservice waarmee Java-softwareclients gegevens en objecten kunnen ontdekken en opzoeken via een naam. Het is ontworpen om onafhankelijk te zijn van enige specifieke naamgeving of implementatie van directoryservices.

De JNDI-architectuur bestaat uit een API (Application Programming Interface) en een SPI (Service Provider Interface). Java-applicaties gebruiken deze API om toegang te krijgen tot een verscheidenheid aan naamgeving en directoryservices. Met de SPI kunnen verschillende naam- en directoryservices transparant worden ingeplugd, waardoor de Java-toepassing met behulp van de API van de JNDI-technologie toegang heeft tot hun services.

Zoals u in bovenstaande afbeelding kunt zien, ondersteunt JNDI LDAP, DNS, NIS, NDS, RMI en CORBA. Je kunt het natuurlijk uitbreiden.

Hoe het werkt

In dit voorbeeld gebruikt de Java RMI de JNDI API om objecten in een netwerk op te zoeken. Als u een object wilt opzoeken, hebt u minimaal twee gegevens nodig:

• Waar het object te vinden

Het RMI-register beheert de naambanden, het vertelt u waar u het object kunt vinden.

• De naam van het object

Wat is de naam van een object? Het is meestal een string, het kan ook een object zijn dat de interface Name implementeert.

Stap voor stap

1. Eerst hebt u een register nodig, dat de naambinding beheert. In dit voorbeeld gebruiken we java.rmi.registry.LocateRegistry .

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

2. Zowel client als server hebben een context nodig. Server gebruikt de context om de naam en het object te binden. Client gebruikt de context om de naam op te zoeken en het object op te halen.

   //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. De server bindt de naam en het object

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

4. De client zoekt het object op met de naam "/ neohope / jndi / test01"

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

5. Nu kan de client het object gebruiken

6. Wanneer de server wordt beëindigd, moet u opschonen.

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