开发基于jndi的应用程序

lfzhs

浏览: 76265 次
性别:
来自: 福州

最近访客更多访客>>

GDGZWQZ

summba

hans204

afeulwx

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

网络应用企业应用应用服务器 SUN 网络协议

关键字: 开发基于jndi的应用程序

http://blog.csdn.net/guoyf/archive/2004/09/27/118235.aspx
Java命名和目录接口（Java Naming and Directory Interface ，JNDI）是用于从Java应用程序中访问名称和目录服务的一组API。命名服务即将名称与对象相关联，以便能通过相应名称访问这些对象。而目录服务即其对象具有属性及名称的命名服务。

命名或目录服务允许您集中管理共享信息的存储，这在网络应用程序中很重要，因为它可以使这类应用程序更加一致和易于管理。例如，可以将打印机配置存储在目录服务中，这样所有与打印机相关的应用程序都能够使用它。

本文是一份代码密集型的快速入门指南，让您开始了解和使用JNDI。它：

提供对JNDI的综述。
描述JNDI的特性。
提供使用JNDI开发应用程序过程中的体验。
说明如何使用JNDI访问 LDAP 服务器，比如Sun ONE Directory Server 。
说明如何使用 JNDI 访问J2EE 服务。
提供示例代码，您可以对其进行修改，以用于您自己的应用程序。
JNDI综述

我们所有人每天都在不自知的情况下使用命名服务。例如，当您在浏览器中输入URL http://java.sun.com 时，域名系统（Domain Name System ，DNS）将这个以符号表示的URL转换为一个通信标识符（IP地址）。在命名系统中，对象的范围可以从位于DNS记录中的名称变动到应用程序服务器中的企业JavaBeans组件（Enterprise JavaBeans Components ，EJBs），还可以到轻量级目录访问协议（Lightweight Directory Access Protocol ，LDAP）中的用户配置文件。

目录服务是命名服务的自然扩展。二者的关键区别在于，目录服务允许属性（比如用户的电子邮件地址）与对象相关联，而命名服务则不然。这样，使用目录服务时，您可以基于对象的属性来搜索它们。JNDI允许您访问文件系统中的文件，定位远程RMI注册表中的对象，访问诸如LDAP这样的目录服务，并定位网络上的EJB。

很多应用程序选择使用JNDI都可以收到良好的效果，比如LDAP客户端、应用程序启动器、类浏览器、网络管理实用工具，或者甚至是地址簿。

JNDI架构

JNDI架构提供了一个标准的、与命名系统无关的API，这个API构建在特定于命名系统的驱动程序之上。这一层帮助把应用程序和实际的数据源隔离开来，因此无论应用程序是访问LDAP、RMI、DNS还是其他的目录服务，这都没有关系。换句话说，JNDI与任何特定的目录服务实现无关，您可以使用任何目录，只要您拥有相应的服务提供程序接口（或驱动程序）即可，如图1所示。

图1: JNDI架构

注意，关于JNDI有一点很重要，即它同时提供应用程序编程接口（Application Programming Interface ，API）和服务提供程序接口（Service Provider Interface ，SPI）。这样做的实际意义在于，对于您的与命名或目录服务交互的应用程序来说，必须存在用于该服务的一个JNDI服务提供程序，这便是JNDI SPI发挥作用的舞台。一个服务提供程序基本上就是一组类，这些类针对特定的命名和目录服务实现了各种JNDI接口——这与JDBC驱动程序针对特定的数据系统实现各种JDBC接口极为相似。作为一名应用程序开发人员，您不需要担心JNDI SPI.。您只需确保，您为每个想使用的命名或目录服务提供了一个服务提供程序。

J2SE和JNDI

JNDI被包含在Java 2 SDK 1.3 及其更新版本中。它还可以用作JDK 1.1和1.2的一个标准扩展。 Java 2 SDK 1.4.x的最新版本进行了改进，将以下命名/目录服务提供程序包括进来：

轻量级目录访问协议（Lightweight Directory Access Protocol，LDAP) 服务提供程序。
公共对象请求代理架构（Common Object Request Broker Architecture ，CORBA）公共对象服务（Common Object Services ，COS）命名服务提供程序。
Java远程方法调用（ Remote Method Invocation ，RMI）注册表服务提供程序。
域名系统（ Domain Name System ，DNS) 服务提供程序。
有关服务提供程序的更多内容

在这里可以下载一系列服务提供程序。Windows注册表JNDI 提供程序（来自cogentlogic.com）可能会引起您特别的兴趣，因为它允许您访问Windows XP/2000/NT/Me/9x上的注册表。

此外，还可以下载JNDI/LDAP Bootster Pack。这个增强补丁包含对流行的LDAP控件和扩展的支持。它代替了与LDAP 1.2.1服务提供程序捆绑在一起的增强补丁。参见 Controls and Extensions 以获得更多信息。

另一个要考察的有趣的服务提供程序是Sun的Directory Services Markup Language (DSML) v2.0提供程序。 DSML的目标是将目录服务与XML连接起来

JNDI API

JNDI API 包括5个包：

javax.naming: 包含用于访问命名服务的类和接口。例如，它定义了Context接口，该接口是执行查找时命名服务的入口点。
javax.naming.directory:扩展命名包以提供用于访问目录服务的类和接口。例如，它增加了新的属性类，提供代表一个目录上下文的DirContext 接口，并且定义了用于检查和更新与目录对象相关的属性的方法。
javax.naming.event: 当访问命名和目录服务时，为事件通知提供支持。例如，它定义了一个NamingEvent类，用于表示由命名/目录服务生成的事件，以及一个监视NamingEvents 类的, NamingListener 接口。
javax.naming.ldap: 这个包为LDAP 版本 3 扩展操作和空间提供特定的支持，而普通的javax.naming.directory 包没有提供这些支持。
javax.naming.spi: 这个包提供方法以动态插入对通过javax.naming及其相关包访问命名和目录服务的支持。只有那些对创建服务提供程序有着浓厚兴趣的开发人员才应该对这个包感兴趣。
JNDI 上下文

承前所述，命名服务是将名称与对象相关联。这种关联被称为绑定。一组这样的绑定被称为上下文，它提供返回对象的分解或查找操作。其他操作还可能包括绑定与解除绑定名称，以及列出被绑定的名称。注意，可以将一个上下文对象中的名称绑定到具有同样命名惯例的另一个上下文对象上。这被称为子上下文。例如，如果UNIX目录/home 是一个上下文，那么名称与其相关的目录便是子上下文。例如，/home/guests.，这里的guests 便是 home的一个子上下文。

在JNDI中，上下文是使用javax.naming.Context 接口来表示的，而这个接口也正是与命名服务进行交互的主要接口。Context （或稍后将要讨论的DirContext）接口中的每个命名方法都有两种重载的形式：

lookup(String name): 接受一个字符串名称。
lookup(javax.naming.Name): 接受一个结构化的名称，比如CompositeName (一个跨越多个命名系统的名称)或 CompondName (一个位于单个命名系统中的名称)；二者均实现了Name 接口。下面是一个复合名称的例子： cn=mydir,cn=Q Mahmoud,ou=People，还有一个组合名称的例子： cn=mydir,cn=Q Mahmoud,ou=People/myfiles/max.txt (这里的myfiles/max.txt 是代表第二部分的一个文件名)。
javax.naming.InitialContext 是一个实现了 Context接口的类。使用这个类作为您到命名服务的入口点。要创建一个InitialContext 对象，构造器需要采用一组属性，形式为java.util.Hashtable 或其子类之一，比如Properties.。下面是一个例子：

Java代码

Hashtable env = new Hashtable();
// select a service provider factory
env.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.fscontext.RefFSContext");
// create the initial context
Context contxt = new InitialContext(env);

Hashtable env = new Hashtable();
// select a service provider factory
env.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.fscontext.RefFSContext");
// create the initial context
Context contxt = new InitialContext(env);

INITIAL_CONTEXT_FACTORY 指定JNDI服务提供程序中工厂类的名称。该工厂负责为其服务创建一个合适的InitialContext 对象。在上面的代码片断中，指定了用于文件系统服务提供程序的一个工厂类。表1列出了用于所支持的服务提供程序的工厂类。注意，用于文件系统服务提供程序的工厂类需要从Sun Microsystems单独下载，它并没有与J2SE 1.4.x一起发行。

表 1: Context.INITIAL_CONTEXT_FACTORY的值
名称
服务提供程序工厂

文件系统
com.sun.jndi.fscontext.RefFSContextFactory

LDAP
com.sun.jndi.ldap.LdapCtxFactory

RMI
com.sun.jndi.rmi.registry.RegistryContextFactory

CORBA
com.sun.jndi.cosnaming.CNCtxFactory

DNS
com.sun.jndi.dns.DnsContextFactory

要通过来自命名或目录服务的名称检索或解析（查找）一个对象，使用Context: Object obj = contxt.lookup(name)的lookup方法。lookup 方法返回一个对象，该对象代表您想要查找的上下文的子上下文。

一个命名的例子

现在，让我们看一看一个使用命名服务的例子。在这个例子中，我们编写了一个简单的程序，用于查找一个其名称被当作命令行参数传入的对象。在这里，我们将使用一个用于文件系统的服务提供程序，而且因此，我们提供作为参数的名称必须是一个文件名。示例代码1中给出了相应代码。

示例代码 1: Resolve.java

Java代码

import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import java.util.Hashtable;
public class Resolve {
public static void main(String argv[]) {
// The user should provide a file to lookup
if (argv.length != 1) {
System.err.println("Usage: java Resolve ");
System.exit(-1);
}
String name = argv[0];
// Here we use the file system service provider
Hashtable env = new Hashtable();
env.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.fscontext.RefFSContextFactory");
try {
// Create the initial context
Context ctx = new InitialContext(env);
// Look up an object
Object obj = ctx.lookup(name);
// Print it out
System.out.println(name + " is bound to: " + obj);
// Close the context
ctx.close();
} catch (NamingException e) {
System.err.println("Problem looking up " + name + ": " + e);
}
}
}

import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import java.util.Hashtable;
public class Resolve {
   public static void main(String argv[]) {
      // The user should provide a file to lookup
      if (argv.length != 1) {
         System.err.println("Usage: java Resolve ");
         System.exit(-1);
      }
      String name = argv[0];
      // Here we use the file system service provider
      Hashtable env = new Hashtable();
      env.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.fscontext.RefFSContextFactory");
      try {
         // Create the initial context
         Context ctx = new InitialContext(env);
         // Look up an object
         Object obj = ctx.lookup(name);
         // Print it out
         System.out.println(name + " is bound to: " + obj);
         // Close the context
         ctx.close();
      } catch (NamingException e) {
         System.err.println("Problem looking up " + name + ": " + e);
      }
   }
}

在这里，我假定您使用的是Java 2SDK 1.4.x，它附带有几个服务提供程序（上面已经列出）。这个应用程序要使用文件系统服务提供程序，而在默认情况下，文件系统服务提供程序并未安装。因此，您需要下载并安装它。另一方面，如果您运行这个程序，而服务提供程序却还没有被安装，您将得到一个NoInitialContextException，意指无法找到服务提供程序工厂类，因此不能初始化这个类。接着，您需要在您的classpath中包括fscontext.jar 和providerutil.jar——或者像我一样，您可以简单地将这两个文件拷贝至JAVA_HOME\jre\lib\ext，这里的 JAVA_HOME 是指您的Java 2SDK安装的根目录。

要测试这个应用程序：

1. 确保您已经下载并安装了文件系统服务提供程序（正如上一段所讲的那样），因为这个服务提供程序并没有与J2SE 1.4.x一起提供。

2. 拷贝代码并将其粘贴到文件中，并将文件命名为Resolve.java。

3. 使用javac 编译 Resolve.java 。

4. 使用java 解释器运行应用程序。

下面是一次示范运行：

prompt> java Resolve \classes
\classes is bound to: com.sun.jndi.fscontext.FSContext@f62373

如果您提供的名称是一个文件名，您将看到如下结果：

prompt> java Resolve \classes\Resolve.java
\classes\Resolve.java is bound to: C:\classes\Resolve.java

列出文件目录的内容

现在，让我们看一看如何使用其他JNDI API列出一个文件目录的内容。我们假定，您想让用户能够使用file:///这样的URL 来指定命令行参数。在这种情况下，您要设置一个新的属性PROVIDER_URL，如示例代码2所示。Context 的listBindings 方法返回一个 NamingEnumeration对象，可以通过使用一个while 循环来迭代这个对象，如示例代码 2所示。
示例代码 2 Resolve2.java

Java代码

import javax.naming.Binding;
import javax.naming.NamingEnumeration;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import java.util.Hashtable;
public class Resolve2 {
public static void main(String argv[]) {
// The user should provide a file to lookup
if (argv.length != 1) {
System.err.println("Usage: java Resolve2 ");
System.exit(-1);
}
// Here we use the file system service provider
Hashtable env = new Hashtable();
env.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.fscontext.FSContextFactory");
env.put(Context.PROVIDER_URL, argv[0]);
try {
// Create the initial context
Context ctx = new InitialContext(env);
NamingEnumeration ne = ctx.listBindings("");
while(ne.hasMore()) {
Binding b = (Binding) ne.next();
System.out.println(b.getName() + " " + b.getObject());
}
// close the context
ctx.close();
} catch (NamingException e) {
System.err.println("Problem looking up " + argv[0] + ": " + e);
}
}
}

import javax.naming.Binding;
import javax.naming.NamingEnumeration;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import java.util.Hashtable;
public class Resolve2 {
   public static void main(String argv[]) {
      // The user should provide a file to lookup
      if (argv.length != 1) {
         System.err.println("Usage: java Resolve2 ");
         System.exit(-1);
      }
      // Here we use the file system service provider
      Hashtable env = new Hashtable();
      env.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.fscontext.FSContextFactory");
      env.put(Context.PROVIDER_URL, argv[0]);
      try {
         // Create the initial context
         Context ctx = new InitialContext(env);
         NamingEnumeration ne = ctx.listBindings("");
         while(ne.hasMore()) {
           Binding b = (Binding) ne.next();
           System.out.println(b.getName() + " " + b.getObject());
         }
         // close the context
         ctx.close();
      } catch (NamingException e) {
         System.err.println("Problem looking up " + argv[0] + ": " + e);
      }
   }
}

要测试这个应用程序，遵照与上一个例子同样的编辑和运行步骤即可。下面是一次示范运行：

prompt>: java Resolve2 file:///uddi
fig1.gif C:\uddi\fig1.gif
fig2.gif C:\uddi\fig2.gif
fig3.gif C:\uddi\fig3.gif
fig4.gif C:\uddi\fig4.gif
fig5.gif C:\uddi\fig5.gif
impl.txt C:\uddi\impl.txt

目录服务

承前所述，目录服务便是其对象具有属性及名称的命名服务。具有属性和名称的对象被称为目录入口。应用程序可以使用目录服务存储和检索目录对象的属性。它甚至可以被用于对象存储。
LDAP

轻量级目录访问协议(LDAP)来源于X.500 协议（由位于Ann Arbor的密歇根大学开发），是一个用于访问和管理目录服务的协议；它定义了客户端应该如何访问存储在服务器上的数据，但没有定义应该如何存储数据。LDAP目录由带有描述性信息的入口组成，这些描述性信息描述了人（例如，姓名、电话号码、电子邮件地址，等等）或网络资源（比如打印机、传真机之类的）。这类描述性信息被存储在一个入口的属性中，入口的每个属性均描述了一种特定类型的信息。下面给出一个例子，内容是用于描述一个人的属性：

cn: Qusay H. Mahmoud
mail: qmahmoud@javacourses.com
telephoneNumber: 123-4567

LDAP 目录服务可以用于基于属性查找某个人的电话号码或电子邮件地址。表2列出了一些常见的LDAP 属性：

表 2: 一些常见的 LDAP 属性
属性
意义
o
组织
cn
常用名
sn
姓

uid
用户id

mail
电子邮件地址
c
国家

LDAP名称是一个 (名称，值) 对的序列，比如姓名、组织、国家。

cn=Qusay Mahmoud, o=javacourses.com, c=Canada

javax.naming.directory.DirContext是一个JNDI的目录服务接口，它扩展了javax.naming.Context。它提供的方法有：

search: 搜索匹配目录入口的目录，并比较一个目录入口和一组属性。
bind 和createSubcontext: 添加一个新的目录入口。
modifyAttributes: 修改一个目录入口的特定属性。rename 方法可以用于修改入口名称本身。
unbind 和destroySubcontext: 删除一个特定的目录入口。
close: 结束与一台LDAP服务器的会话。
使用JNDI 进行LDAP编程

要操作一台LDAP 服务器(比如Sun ONE Directory Server)中的对象，您必须首先连接到该服务器；您可能还需要使您自己通过服务器的身份验证。要连接到服务器，您可以从DirContext 接口获得对一个对象的引用。使用InitialDirContext 类可以做到这一点，而该类需要一个 Hashtable。

下面的代码片断可以使用户通过一台LDAP服务器的身份验证，并连接到该服务器上。注意，这里使用的是简单的身份验证。简单身份验证包括把用户的完全限定的DN和用户的明文口令发送给LDAP 服务器。要避免暴露明文口令，使用带有加密通道的SSL机制，如果您的LDAP服务器支持这种机制的话。想要了解关于身份验证模式的更多信息，请参见 JNDI Tutorial。

Hashtable env = new Hashtable();

env.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.ldap.LdapCtxFactory");

// specify where the ldap server is running

env.put(Context.PROVIDER_URL, "ldap://GH308C-N-MAHMOUD.humber.org:61596");

env.put(Context.SECURITY_AUTHENTICATION, "simple");

env.put(Context.SECURITY_PRINCIPAL, "cn=Directory Manager");

env.put(Context.SECURITY_CREDENTIALS, "password");

// Create the initial directory context

DirContext ctx = new InitialDirContext(env);

连接到LDAP 服务器上之后，您可以在LDAP服务器上添加新的入口、或者修改、删除、搜索一个入口。下面的代码片断说明了如何添加或存储一个新的入口。注意：要存储一个对象，您需要使用Java Schema装载它，而 Java Schema并没有在目录服务器上被预配置。想要了解关于此点的更多信息，请参见JNDI指南中的Java Objects and the Directory 部分。

SomeObject Obj = new SomeObjct("param1", "param2", "param3");

ctx.bind("cn=myobject", obj);

您可以使用lookup 方法查找一个对象，如下：

SomeObject obj = (SomeObject) ctx.lookup("cn=myobject");

示例代码3 给出了一个如何检索命名对象的属性的例子。正如您所看到的那样，用于选择工厂类的代码与前面相同。我们使用InitialDirContext 类创建了一个目录上下文DirContext，getAttributes 方法用于返回对象的属性，而最后，get方法找到了姓并打印之。相当直观，是不是？

示例代码 3: GetAttrib.java

import javax.naming.Context;

import javax.naming.directory.InitialDirContext;

import javax.naming.directory.DirContext;

import javax.naming.directory.Attributes;

import javax.naming.NamingException;

import java.util.Hashtable;

class GetAttrib {

   public static void main(String[] argv) {

      Hashtable env = new Hashtable();

      env.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.ldap.LdapCtxFactory");

      // specify where the ldap server is running

      env.put(Context.PROVIDER_URL, "ldap://localhost:389/o=javacourses.com,c=Canada");

      // use simple authenticate to authenticate the user

      env.put(Context.SECURITY_AUTHENTICATION, "simple");

      env.put(Context.SECURITY_PRINCIPAL, "cn=Directory Manager");

      env.put(Context.SECURITY_CREDENTIALS, "password");

      try {

         // Create the initial directory context

         DirContext ctx = new InitialDirContext(env);

         // Ask for all attributes of the object

         Attributes attrs = ctx.getAttributes("cn=Qusay Mahmoud");

         // Find the surname ("sn") attribute of this object and print it

         System.out.println("Last Name: " + attrs.get("sn").get());

         // Close the context

         ctx.close();

      } catch (NamingException e) {

         System.err.println("Problem getting attribute: " + e);

      }

   }

}

JNDI提供用于进行基本和高级（使用过滤器）搜索的 API 。例如，使用一组入口必须具有的属性，以及要在其中执行搜索的目标上下文，便可以执行一次简单的搜索。下面的代码片断说明了如何在一棵子树中搜索一个具有uid=qmahmoud 属性的入口。使用过滤器的高级搜索不在本文的讨论范围之内。

// ignore attribute name case

Attributes matchattribs = new BasicAttributes(true);

matchattribs.put(new BasicAttribute("uid", "qmahmoud"));

// search for objects with those matching attributes

NamingEnumeration answer = ctx.search("ou=People,o=javacourses.com", matchattribs);

while (answer.hasMore()) {

SearchResult sr = (SearchResult)answer.next();

// print the results you need

}

想要了解使用JNDI编写LDAP 客户端方面的更多信息，请参见Tips for LDAP Users。

JNDI 的CORBA COS命名服务提供程序

CORBA 公共对象服务 (COS) 名称服务器用于存储CORBA对象引用。您可以使用COS命名包(org.omg.CORBA.CosNaming)在CORBA 应用程序中访问它。

JNDI COS命名服务提供程序基于COS命名包实现了javax.naming.Context 接口，这样CORBA 应用程序就能够使用JNDI访问 COS 名称服务器。因此，使用 JNDI 的CORBA 应用程序具有一个用于访问所有命名和目录服务的接口。这使得CORBA应用程序能够使用像LDAP这样的分布式企业级服务来存储对象引用。

要选择COS 命名服务提供程序，使用：

env.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.cosnaming.CNCtxFactory");

要转换您的CORBA 应用程序以使用JNDI，考虑AddServer.java 和AddClient.java，它们在另一篇文章中有更加详细的描述。

1.         在客户端和服务器中均使用javax.naming，将：

import org.omg.CosNaming.*;

import org.omg.CosNaming.NamingContextPackage.*;

替换为：

import javax.naming.*;

2.         在客户端和服务器中使用InitialContext 代替 NameService ：

将：

org.omg.CORBA.Object objRef =

        orb.resolve_initial_references("NameService");

NamingContextExt ncRef =

        NamingContextExtHelper.narrow(objRef);

替换为：

Hashtable env = new Hashtable();

env.put("java.naming.corba.orb", orb);

Context ctx = new InitialContext(env);

3.         使用lookup 代替resolve：

将:

String name = "Add";

Add href = AddHelper.narrow(ncRef.resolve_str(name));

替换为：

Add href = AddHelper.narrow((org.omg.CORBA.Object)ctx.lookup("Add"));

JNDI 的RMI 注册表服务提供程序

RMI 注册表服务提供程序允许JNDI 应用程序访问使用RMI注册表注册的远程对象。已知注册表所在的位置之后，提供程序使用绑定为注册在注册表中的对象创建一个命名上下文。接下来，这个上下文可以被绑定到另一个JNDI可访问的命名空间中，比如LDAP。这项新功能包含了java.rmi.Naming 类提供的功能。

这样使用RMI的主要优点是，客户端不再需要知道RMI注册表运行之处的主机名和端口号；它与位置无关。

下面的代码片断说明了如何将JNDI 与 RMI一起使用：

// select the registry service provider as the initial context

env.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.rmi.registry.RegistryContextFactory");
// specify where the registry is running
env.put(Context.PROVIDER_URL, "rmi://server:1099");
// create an initial context that accesses the registry
   Context ctx = new InitialContext(env);
   // now, the names stored in registry can be listed
   NamingEnumeration enum = ctx.list("");
   // bind the registry context into LDAP directory
   Context ldapctx = (Context)ctx.lookup."ldap://server:port/o=comp,c=ca");
ldapctx.bind("cn=rmi", ctx);

JNDI 的DNS 服务提供程序

DNS服务提供程序使得基于JNDI的应用程序能够访问存储在DNS中的信息。DNS服务提供程序将DNS命名空间呈现为JNDI 目录上下文的一棵树，而将DNS 资源记录呈现为JNDI 属性。

示例代码 4 演示了如何使用DNS 服务提供程序检索环境和IP地址（A记录）的信息。

示例代码 4: TestDNS.java

Java代码

import javax.naming.*;
import com.sun.jndi.dns.*;
import java.util.Hashtable;
public class TestDNS {
public static void main(String[] argv) {
Name cn = null;
String name = argv[0];
Hashtable env = new Hashtable();
env.put(Context.INITIAL_CONTEXT_FACTORY,
"com.sun.jndi.dns.DnsContextFactory");
env.put(Context.PROVIDER_URL, "dns://IP for DNS Server/");
try {
// Create the initial context
Context ctx = new InitialContext(env);
// print the fully qualified name (.)
System.out.println("Name in namespace: "+ctx.getNameInNamespace());
// retrieve the parser associated with the named context
NameParser np = ctx.getNameParser(ctx.getNameInNamespace());
if (argv.length != 1) {
System.out.println("Usage: java TestDNS ");
System.exit(-1);
}
// parse the name into its components and print them
cn = np.parse(name);
System.out.println("Name is: "+cn.toString());
System.out.println("The parsed name has "+cn.size()+" components:");
for (int i=0; i<cn.size(); i++){
System.out.println(cn.get(i));
}
System.out.print("Trying to lookup ");
// get the prefix (domain) and suffix (hostname)
Name domain = cn.getPrefix(cn.size()-1);
Name host = cn.getSuffix(cn.size()-1);
System.out.println("DNS Host: "+host+" Domain: "+domain);
// retrieve the named object
Object obj = ctx.lookup(domain);
System.out.println(domain.toString()+" is bound to: "+obj);
// retrieve and print the environment in effect
System.out.println("Domain properties: "+ ((Context)obj).getEnvironment());
// retrieve and print the IP address (the DNS A records)
System.out.println("IP for: "+cn+ " is: "+
((DnsContext)obj).getAttributes(host, new String[]{"A"}));
// we're done so close the context
ctx.close();
} catch (NamingException e) {
System.err.println("Problem looking up " + cn + ": " + e);
}
}
}

import javax.naming.*;
import com.sun.jndi.dns.*;
import java.util.Hashtable;
public class TestDNS {
   public static void main(String[] argv) {
      Name cn = null;
      String name = argv[0];
      Hashtable env = new Hashtable();
      env.put(Context.INITIAL_CONTEXT_FACTORY,
                     "com.sun.jndi.dns.DnsContextFactory");
      env.put(Context.PROVIDER_URL, "dns://IP for DNS Server/");
      try {
         // Create the initial context
         Context ctx = new InitialContext(env);
         // print the fully qualified name (.)
         System.out.println("Name in namespace: "+ctx.getNameInNamespace());
         // retrieve the parser associated with the named context
         NameParser np = ctx.getNameParser(ctx.getNameInNamespace());
          if (argv.length != 1) {
            System.out.println("Usage: java TestDNS ");
            System.exit(-1);
         }
         // parse the name into its components and print them
         cn = np.parse(name);
         System.out.println("Name is: "+cn.toString());
         System.out.println("The parsed name has "+cn.size()+" components:");
         for (int i=0; i<cn.size(); i++){
            System.out.println(cn.get(i));
         }
         System.out.print("Trying to lookup ");
         // get the prefix (domain) and suffix (hostname)
         Name domain = cn.getPrefix(cn.size()-1);
         Name host = cn.getSuffix(cn.size()-1);
         System.out.println("DNS Host: "+host+" Domain: "+domain);
         // retrieve the named object
         Object obj = ctx.lookup(domain);
         System.out.println(domain.toString()+" is bound to: "+obj);
         // retrieve and print the environment in effect
         System.out.println("Domain properties: "+ ((Context)obj).getEnvironment());
         // retrieve and print the IP address (the DNS A records)
         System.out.println("IP for: "+cn+ " is: "+
                            ((DnsContext)obj).getAttributes(host, new String[]{"A"}));
        // we're done so close the context
         ctx.close();
      } catch (NamingException e) {
         System.err.println("Problem looking up " + cn + ": " + e);
      }
   }
}

在您运行这个应用程序之前，确保您指定了DNS服务器的IP地址。

下面是一次示范运行：

prompt> java TestDNS prep.ai.mit.edu

Name in namespace: .

Name is: prep.ai.mit.edu

The parsed name has 4 components:

edu

mit

ai

prep

Trying to lookup DNS Host: prep Domain: ai.mit.edu

ai.mit.edu is bound to: com.sun.jndi.dns.DnsContext@b89838

Domain properties: {java.naming.provider.url=dns://IP for DNS Server/, java.namin

g.factory.initial=com.sun.jndi.dns.DnsContextFactory}

IP for: prep.ai.mit.edu is: {a=A: 199.232.41.9}

JNDI 和J2EE

JNDI 是J2EE平台的标准服务API之一。包含它的目的是为应用程序组件提供一个标准的API，用于引用资源和其他应用程序组件。J2EE还定义了一种标准的命名策略（逻辑和真实的名称），以和 JNDI一起使用，这样就可以采用一种与部署环境无关的方式编写应用程序。您可以引用 J2EE服务，具体方法是根据其逻辑名称在目录中查找它们。为了实现这一点，每个符合 J2EE规范的系统均提供了一个称为环境的JNDI 服务，该环境包括：

环境变量
EJB 引用
资源工厂引用
注意：在这里，我只讨论环境变量。想要了解EJB引用和资源工厂引用方面的更多信息，请参见这篇文章。

环境变量

应用程序组件的命名环境允许您定制应用程序组件，而不需要访问或修改组件的源代码。每个应用程序组件定义它自己的环境入口的集合。同一个容器中，一个应用程序组件的所有实例共享同一个入口。注意，不允许应用程序组件实例在运行时修改环境。

声明环境变量

应用程序组件提供程序必须声明从应用程序的组件代码访问的所有环境入口。它们是在部署描述器(例如Tomcat中的web.xml)中通过使用<env-entry> 标签来声明的. <env-entry> 标签的元素有：

<description>:环境入口的可选描述。
<env-entry-name>: 环境入口名。
<env-entry-type>:期望的环境变量类型。它可以是以下 Java 类型之一： Boolean、Byte、 Double、Character、 Float、 Integer、 Long、Short、String 。
<env-entry-value>: 必须匹配所提供类型的环境入口值。
<env-entry-type>. 这个值可以稍后改变，但是如果它没有被设定，那么在部署期间必须为它指定一个值。
示例代码 5中的例子给出了两个环境入口的声明。要为一个新环境指定一个声明，您只要把它添加给您的web应用程序描述器 (web.xml) 即可。

示例代码 5: 声明环境变量

<env-entry>

<description>welcome message</description>

<env-entry-name>greetings</env-entry-name>

<env-entry-type>java.lang.String</env-entry-type>

<env-entry-value>Welcome to the Inventory Control

System</env-entry-value>
</env-entry>
<env-entry>
<description>maximum number of products</descriptor>
<env-entry-name>inventory/max</env-entry-name>
<env-entry-type>java.lang.Integer</env-entry-type>
<env-entry-value>27</env-entry-value>
</env-entry>

每个<env-entry>标签描述一个环境入口。所以在这个例子中，定义了两个环境入口。第一个叫做greetings, 是 String 类型，初始的默认值为： Welcome to the Inventory Control System。第二个入口叫做 inventory/max，是 Integer类型，初始的默认值为 27。

现在，应用程序组件实例可以使用JNDI定位环境入口. 它使用不带参数的构造器创建了一个javax.naming.InitialContext 对象。接着，它通过InitialContext查找命名环境，所使用的是以java:comp/env打头的JNDI URL。示例代码 6 说明了一个应用程序组件如何访问它的环境入口。

示例代码 6: 访问环境入口

Java代码

// obtain the application component's environment
// naming context
javax.naming.Context ctx =new javax.naming.InitialContext();
javax.naming.Context env =ctx.lookup("java:comp/env");
// obtain the greetings message
//configured by the deployer
String str = (String) env.lookup("greetings");
// use the greetings message
System.out.println(greetings);
// obtain the maximum number of products
//configured by the deployer
Integer maximum = (Integer) env.lookup("inventory/max");
//use the entry to customize business logic

    // obtain the application component's environment
    // naming context
  javax.naming.Context ctx =new javax.naming.InitialContext();
  javax.naming.Context env =ctx.lookup("java:comp/env");
    // obtain the greetings message
   //configured by the deployer
  String str = (String) env.lookup("greetings");
   // use the greetings message
  System.out.println(greetings);
   // obtain the maximum number of products
   //configured by the deployer
  Integer maximum = (Integer) env.lookup("inventory/max");
   //use the entry to customize business logic

注意，应用程序组件还可以使用如下的完整路径名查找环境入口：

javax.naming.Context ctx =new javax.naming.InitialContext();
String str = (String) ctx.lookup("java:comp/env/greetings");

这段代码片断可以用在一个 JSP 页面中，如示例代码 7所示：
示例代码 7: 从一个 JSP页面访问环境入口

Java代码

<HTML>
<HEAD>
<TITLE>JSP Example</TITLE>
</HEAD>
<BODY BGCOLOR="#ffffcc">
<CENTER>
<H2>Inventory System</H2>
<%javax.naming.Context ctx =new javax.naming.InitialContext();
javax.naming.Context myenv =(javax.naming.Context) t.lookup("java:comp/env");
java.lang.String s = (java.lang.String) myenv.lookup("greetings");
out.println("The value is: "+greetings);
%>
</CENTER>
</BODY>
</HTML>

<HTML>
  <HEAD>
    <TITLE>JSP Example</TITLE>
  </HEAD>
  <BODY BGCOLOR="#ffffcc">
   <CENTER>
   <H2>Inventory System</H2>
  <%javax.naming.Context ctx =new javax.naming.InitialContext();
  javax.naming.Context myenv =(javax.naming.Context) t.lookup("java:comp/env");
  java.lang.String s = (java.lang.String) myenv.lookup("greetings");
  out.println("The value is: "+greetings);
%>
  </CENTER>
</BODY>
</HTML>

结束语

JNDI是使用命名/目录服务增强您的网络应用程序的一组 API。本文通篇给出的例子演示了，开始使用JNDI开发基于目录的应用程序是一件多么简单的事情。这些例子还演示了如何使用相同的API访问不同的命名/目录服务。开发人员不必学习不同的 API。在某些情况下，比如在 RMI 和 CORBA应用程序中， JNDI 允许您将命名服务的选择延至部署阶段。

对JNDI 未来的期望有：与标准的Java SASL API (JSR-28)结合，支持国际化的域名，而且支持安全的 DNS 。

要开始学习和使用JNDI 和 LDAP，下载Sun ONE Directory Server的试用版，它可以用于各种平台和各种语言。

更多信息

LDAP v3
JNDI
The JNDI Tutorial
JNDI Service Providers
Sun ONE Directory Server
JNDI-INTEREST Mailing List (for discussing JNDI)

致谢

特别感谢Sun Microsystems的 Jaya Hangal 和 Rosanna Lee，他们的反馈帮助我完善了本文。

分享到：