Java Language
JNDI

RMI a través de JNDI

Este ejemplo muestra cómo funciona JNDI en RMI. Tiene dos roles:

• para proporcionar al servidor una API de vinculación / desvinculación / rebobinado al registro de RMI
• para proporcionar al cliente una API de búsqueda / lista para el registro de RMI.

El registro de RMI es parte de RMI, no JNDI.

Para hacer esto simple, usaremos java.rmi.registry.CreateRegistry() para crear el Registro RMI.

1. Server.java (el servidor JNDI)

   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 (el cliente JNDI)

   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 (clase de servidor RMI)

   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;
       }
   }
   

Cómo ejecutar el eaxmple:

1. construir e iniciar el servidor
2. construir e iniciar el cliente

Introducir

La interfaz de nombres y directorios de Java (JNDI) es una API de Java para un servicio de directorio que permite a los clientes de software de Java descubrir y buscar datos y objetos a través de un nombre. Está diseñado para ser independiente de cualquier implementación específica de servicios de nombres o directorios.

La arquitectura JNDI consta de una API (interfaz de programación de aplicaciones) y una SPI (interfaz de proveedor de servicios). Las aplicaciones Java utilizan esta API para acceder a una variedad de servicios de nombres y directorios. El SPI permite la conexión transparente de una variedad de servicios de nombres y directorios, lo que permite que la aplicación Java que utiliza la API de la tecnología JNDI acceda a sus servicios.

Como puede ver en la imagen de arriba, JNDI admite LDAP, DNS, NIS, NDS, RMI y CORBA. Por supuesto, puedes ampliarlo.

Cómo funciona

En este ejemplo, el RMI de Java utiliza la API JNDI para buscar objetos en una red. Si desea buscar un objeto, necesita al menos dos datos:

• Donde encontrar el objeto

El registro de RMI administra los enlaces de nombre, le indica dónde encontrar el objeto.

• El nombre del objeto

¿Cuál es el nombre de un objeto? Generalmente es una cadena, también puede ser un objeto que implementa la interfaz de nombre.

Paso a paso

1. Primero necesita un registro, que administre el enlace de nombre. En este ejemplo, usamos java.rmi.registry.LocateRegistry .

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

2. Tanto el cliente como el servidor necesitan un contexto. El servidor utiliza el contexto para enlazar el nombre y el objeto. El cliente usa el contexto para buscar el nombre y obtener el objeto.

   //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. El servidor enlaza el nombre y el objeto.

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

4. El cliente busca el objeto con el nombre "/ neohope / jndi / test01"

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

5. Ahora el cliente puede usar el objeto.

6. Cuando el servidor está terminando, necesita limpiar.

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