Java Language
JNDI

RMI genom JNDI

Detta exempel visar hur JNDI fungerar i RMI. Det har två roller:

• för att förse servern med ett bindande / avlindat / återställnings-API till RMI-registret
• för att förse klienten med en söknings- / lista-API till RMI-registret.

RMI-registret är en del av RMI, inte JNDI.

För att göra detta enkelt kommer vi att använda java.rmi.registry.CreateRegistry() att skapa RMI-registret.

1. Server.java (JNDI-servern)

   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 (JNDI-klienten)

   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-serverklass)

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

Hur man kör eaxmple:

1. bygga och starta servern
2. bygga och starta klienten

Införa

Java Naming and Directory Interface (JNDI) är ett Java API för en katalogtjänst som gör det möjligt för Java-programvaruklienter att upptäcka och slå upp data och objekt via ett namn. Den är utformad för att vara oberoende av någon specifik namngivning eller implementering av katalogtjänster.

JNDI-arkitekturen består av ett API (Application Programming Interface) och ett SPI (Service Provider Interface). Java-applikationer använder detta API för att få tillgång till olika namn- och katalogtjänster. SPI gör det möjligt att koppla in olika namn- och katalogtjänster på ett öppet sätt, vilket gör att Java-applikationen som använder API: n av JNDI-tekniken kan komma åt sina tjänster.

Som ni ser från bilden ovan stöder JNDI LDAP, DNS, NIS, NDS, RMI och CORBA. Naturligtvis kan du förlänga det.

Hur det fungerar

I det här exemplet använder Java RMI JNDI API för att leta upp objekt i ett nätverk. Om du vill leta upp ett objekt behöver du minst två informationer:

• Var hittar du objektet

RMI-registret hanterar namnbindningarna, det berättar var du kan hitta objektet.

• Namnet på objektet

Vad heter ett objekt? Det är vanligtvis en sträng, det kan också vara ett objekt som implementerar namngränssnittet.

Steg för steg

1. Först behöver du ett register som hanterar namnbindningen. I det här exemplet använder vi java.rmi.registry.LocateRegistry .

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

2. Både klient och server behöver ett sammanhang. Servern använder kontext för att binda namn och objekt. Klient använder kontext för att leta upp namnet och få objektet.

   //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. Servern binder namn och objekt

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

4. Klienten letar upp objektet med namnet "/ 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 klienten använda objektet

6. När servern avslutas måste du städa upp.

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