JNDI全面总结

原理：
         在DataSource中事先建立多个数据库连接，保存在数据库连接池中。当程序访问数据库时，只用从连接池中取空闲状态的数据库连接即可，访问结束，销毁资源，数据库连接重新回到连接池，这与每次去直接访问数据库相比，会节省大量时间和资源。
         JNDI( Java Naming and Directory Interface )，是Java平台的一个标准扩展，提供了一组接口、类和关于命名空间的概念。如同其它很多Java技术一样，JDNI是provider-based的技术，暴露了一个 API和一个服务供应接口（SPI）。这意味着任何基于名字的技术都能通过JNDI而提供服务，只要JNDI支持这项技术。JNDI目前所支持的技术包括 LDAP、CORBA Common Object Service（COS）名字服务、RMI、NDS、DNS、Windows注册表等等。很多J2EE技术，包括EJB都依靠JNDI来组织和定位实体。可以把它理解为一种将对象和名字捆绑的技术，对象工厂负责生产出对象，这些对象都和唯一的名字绑在一起，外部资源可以通过名字获得某对象的引用。

          在javax.naming的包包中提供Context接口，提供了两个很好用的方法：
<1> void bind( String name , Object object )
        将名称绑定到对象。所有中间上下文和目标上下文（由该名称最终原子组件以外的其他所有组件指定）都必须已经存在。
<2>Object lookup( String name )
       检索指定的对象。如果 name为空，则返回此上下文的一个新实例（该实例表示与此上下文相同的命名上下文，但其环境可以独立地进行修改，而且可以并发访问）。

运行机制：
1、 首先程序代码获取初始化的 JNDI 环境并且调用 Context.lookup() 方法从 JNDI 服务提供者那里获一个 DataSource 对象

2、 中间层 JNDI 服务提供者返回一个 DataSource 对象给当前的 Java 应用程序这个 DataSource 对象代表了中间层服务上现存的缓冲数据源

 3、 应用程序调用 DataSource 对象的 getConnection() 方法

4、 当 DataSource 对象的 getConnection() 方法被调用时，中间层服务器将查询数据库 连接缓冲池中有没有 PooledConnection 接口的实例对象。这个 PooledConnection 对象将被用于与数据库建立物理上的数据库连接

5、 如果在缓冲池中命中了一个 PooledCoonection 对象那么连接缓冲池将简单地更 新内部的缓冲连接队列并将该 PooledConnection 对象返回。如果在缓冲池内没 有找到现成的 PooledConnection 对象，那么 ConnectionPoolDataSource 接口将会被 用来产生一个新的 PooledConnection 对象并将它返回以便应用程序使用

6。 中间层服务器调用 PooledConnection 对象的 getConnection() 方法以便返还一个 java.sql.Connection 对象给当前的 Java 应用程序

7、 当中间层服务器调用 PooledConnection 对象的 getConnection() 方法时， JDBC 数据 库驱动程序将会创建一个 Connection 对象并且把它返回中间层服务器

8、 中间层服务器将 Connection 对象返回给应用程序 Java 应用程序，可以认为这个 Connection 对象是一个普通的 JDBC Connection 对象使用它可以和数据库建立。事 实上的连接与数据库引擎产生交互操作 。

9、 当应用程序不需要使用 Connection 对象时，可以调用 Connection 接口的 close() 方 法。请注意这种情况下 close() 方法并没有关闭事实上的数据库连接，仅仅是释 放了被应用程序占用的数据库连接，并将它还给数据库连接缓冲池，数据库连接 缓冲池会自动将这个数据库连接交给请求队列中下一个的应用程序使用。

 

现在，数据库的连接没有用到连接池几乎很少很少，每个项目组都可能有自己的数据库连接池组件，各容器提供商也提供了各自的数据库连接池，下面介绍一下tomcat的数据库连接管理。
tomcat6 数据源配置（server.xml方式和context.xml方式）

在server.xml下配置你必需重启服务器才能生效，而context.xml配置保存后tomcat会自动加载无需重启
在JNDI配配置数据源中需注意：项目下需要引入数据库驱动包，并且TOMCAT下也需要引入，不然会报错的
1.context.xml方式
Tomcat-6.0.26\conf\context.xml文件当添加以下的配置信息：
<Resource name="jdbc/mysql" auth="Container" type="javax.sql.DataSource"
               maxActive="100" maxIdle="30" maxWait="60" wait_timeout="18800" timeBetweenEvictionRunsMillis="300000" minEvictableIdleTimeMillis="600000"
               username="root" password="jdzxdb" driverClassName="com.mysql.jdbc.Driver"
               url="jdbc:mysql://localhost:3306/sxtele?comautoReconnect=true&amp;failOverReadOnly=false"  removeAbandoned="true" removeAbandonedTimeout="60" logAbandoned="true"/>
<Resource name="jdbc/db2" auth="Container" type="javax.sql.DataSource"
               maxActive="100" maxIdle="30" maxWait="60" wait_timeout="18800" timeBetweenEvictionRunsMillis="300000" minEvictableIdleTimeMillis="600000"
               username="lcgluser" password="lcgluser" driverClassName="com.ibm.db2.jcc.DB2Driver"
               url="jdbc:db2://133.64.46.65:50000/STEDWDB"  removeAbandoned="true" removeAbandonedTimeout="60" logAbandoned="true"/>
 其中：
name 表示指定的jndi名称
auth 表示认证方式，一般为Container
type 表示数据源床型，使用标准的javax.sql.DataSource
maxActive 表示连接池当中最大的数据库连接
maxIdle 表示最大的空闲连接数
maxWait 当池的数据库连接已经被占用的时候，最大等待时间
logAbandoned 表示被丢弃的数据库连接是否做记录，以便跟踪
username 表示数据库用户名
password 表示数据库用户的密码
driverClassName 表示JDBC DRIVER
url 表示数据库URL地址

 

注意，这里你配置的name值要和程序中使用的是一样的，比如按照这个例子，程序就应该是这样的

Java代码
String gENV = "java:comp/env/";  
Context ctx = new InitialContext();    
      DataSource ds = (DataSource)ctx .lookup(gENV+"jdbc/mysql");  
      Connection conn = ds.getConnection(); 

String gENV = "java:comp/env/";
Context ctx = new InitialContext();
      DataSource ds = (DataSource)ctx.lookup(gENV+"jdbc/db2");
      Connection conn = ds.getConnection();

 

关于获取数据源的语法，大体有(javax.sql.DataSource) ctx.lookup ("java:comp/env/XXX")和(javax.sql.DataSource) ctx.lookup("XXX")两种写法，好多人以为这两种写法是相同的，以为都是通过JNDI来获取数据源。其实java:comp/env和 JNDI是不同的，java:comp/env 是环境命名上下文（environment naming context（ENC）），是在EJB规范1.1以后引入的，引入这个是为了解决原来JNDI查找所引起的冲突问题，也是为了提高EJB或者J2EE应用的移植性。ENC是一个引用，引用是用于定位企业应用程序的外部资源的逻辑名。引用是在应用程序部署描述符文件中定义的。在部署时，引用被绑定到目标可操作环境中资源的物理位置（JNDI名）。使用ENC是把对其它资源的JNDI查找的硬编码解脱出来，通过配置这个引用可以在不修改代码的情况下，将引用指向不同的EJB(JNDI)。 在J2EE中的引用常用的有： 
---------JDBC 数据源引用在java:comp/env/jdbc 子上下文中声明 
---------JMS 连接工厂在java:comp/env/jms 子上下文中声明 
---------JavaMail 连接工厂在java:comp/env/mail 子上下文中声明 
---------URL 连接工厂在 java:comp/env/url子上下文中声明 

 

2.在server.xml文件中配置数据源
Tomcat-6.0.26\conf\context.xml中的配置：在<Host></Host>中添加如下配置
  <Context path="/sljx" reloadable="true"  docBase="sljx"   crossContext="true"
debug="0">
               <Resource
                   name="jdbc/oracle"
                   type="javax.sql.DataSource"
                   auth="Container"
                   username="sljx"
                   password="sljx"
                   driverClassName="oracle.jdbc.driver.OracleDriver"
                   maxIdle="3000"
                   maxWait="5000"
                   url="jdbc:oracle:thin:@localhost:1521:jadetrus"
                   autoReconnect="true"
                   maxActive="1000"/>
      </Context>
  具体属性解释和JAVA获取数据源跟上面一样

 

3.在hibernate中配置JNDI也很简单在hibernate.cfg.xml中
<property name="connection.datasource">java:/comp/env/jdbc/mysql</property>  
    <property name="dialect">  
        org.hibernate.dialect.MySQLDialect  
    </property> 

常用获取示例
package com.cn.util.db;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.sql.DataSource;

public class DBCache {
 private InitialContext ic;

 private Map<String,DataSource> cache;

 private static DBCache instance = new DBCache();

 private DBCache() {
  try {
   ic = new InitialContext();
  } catch (NamingException e) {
   e.printStackTrace();
  }
  cache = Collections.synchronizedMap(new HashMap<String,DataSource>());
 }

 public static DBCache getInstance() {
  return instance;
 }

 
 public Connection getDBConn(String dataSourceName) throws SQLException,
   NamingException {
  Connection conn = null;
        conn=getDataSource(dataSourceName).getConnection();
       return conn;
 }

 public DataSource getDataSource(String dataSourceName)
   throws NamingException {

  if (cache.containsKey(dataSourceName)) {
   return cache.get(dataSourceName);
  } else {

   DataSource newDataSource = (DataSource) ic.lookup(dataSourceName);
   cache.put(dataSourceName, newDataSource);
   return newDataSource;
  }

 }
 public void removeDateSouceOffCache(String dataSourceName) {
  try {
   DataSource ds = cache.get(dataSourceName);
   ds.getConnection().close();
   cache.remove(dataSourceName);
  } catch (Exception ex) {
  }
 }
 
 
 public static void freeConn(Connection conn) {
  freeConn(conn, null, null);
 }

 public static void freeConn(Connection connection, Statement statement) {
  freeConn(connection, statement, null);
 }

 
 public static void freeConn(Connection conn, Statement ps, ResultSet rs) {
  try {
   try {
    if (rs != null)
     rs.close();
   } finally {
    try {
     if (ps != null)
      ps.close();
    } finally {
     if (conn != null)
      conn.close();
    }
   }
  } catch (SQLException ex) {
   ex.printStackTrace();
  }
 }
}

如果获取连接调用getDBConn传入下面两值中任意一个即可
 public static final String DATA_SOURCE = "java:comp/env/jdbc/localhostMysql";
 public static final String DATA_SOURCE_DB2 = "java:comp/env/jdbc/db2";
        private static final String DATA_SOURCE="java:comp/env/jdbc/oracle";

 

关于JNDI的更多用法
基于JNDI的应用开发
    JNDI（The Java Naming and Directory Interface，Java命名和目录接口）是一组在Java应用中访问命名和目录服务的API.命名服务将名称和对象联系起来，使得我们可以用名称访问对象。目录服务是一种命名服务，在这种服务里，对象不但有名称，还有属性。

    命名或目录服务使你可以集中存储共有信息，这一点在网络应用中是重要的，因为这使得这样的应用更协调、更容易管理。例如，可以将打印机设置存储在目录服务中，以便被与打印机有关的应用使用。

  JNDI概述
    我们大家每天都不知不觉地使用了命名服务。例如，当你在web浏览器输入URL，http://java.sun.com时，DNS（Domain Name System，域名系统）将这个符号URL名转换成通讯标识（IP地址）。命名系统中的对象可以是DNS记录中的名称、应用服务器中的EJB组件（Enterprise JavaBeans Component）、LDAP（Lightweight Directory Access Protocol）中的用户Profile.

    目录服务是命名服务的自然扩展。两者之间的关键差别是目录服务中对象可以有属性（例如，用户有email地址），而命名服务中对象没有属性。因此，在目录服务中，你可以根据属性搜索对象。JNDI允许你访问文件系统中的文件，定位远程RMI注册的对象，访问象LDAP这样的目录服务，定位网络上的EJB组件。

    对于象LDAP 客户端、应用launcher、类浏览器、网络管理实用程序，甚至地址薄这样的应用来说，JNDI是一个很好的选择。

    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

    Java 2 SDK 1.3及以上的版本包含了JNDI.对于JDK 1.1和1.2也有一个标准的扩展。Java 2 SDK 1.4.x的最新版本包括了几个增强和下面的命名/目录服务提供者：

    l LDAP（Lightweight Directory Access Protocol）服务提供者 l CORBA COS（Common Object Request Broker Architecture Common Object Services）命名服务提供者 l RMI（Java Remote Method Invocation）注册服务提供者 l DNS（Domain Name System）服务提供者

    更多的服务提供者

    可以在如下网址找到可以下载的服务提供者列表：

    http://java.sun.com/products/jndi/serviceproviders.html 特别有意思的或许是如下网址提供的Windows 注册表JNDI服务提供者：http://cogentlogic.com/cocoon/CogentLogicCorporation/JNDI.xml 这个服务提供者使你可以访问Windows XP/2000/NT/Me/9x的windows注册表。

      也可以在如下网址下载JNDI/LDAP Booster Pack：http://java.sun.com/products/jndi/ 这个Booster Pack包含了对流行的LDAP控制的支持和扩展。它代替了与LDAP 1.2.1服务提供者捆绑在一起的booster pack.关于控制和扩展的更多信息可以在如下网站看到： http://java.sun.com/products/jndi/tutorial/ldap/ext/index.html 另一个有趣的服务提供者是Sun的支持DSML v2.0（Directory Service Markup Language，目录服务标记语言）的服务提供者。DSML的目的是在目录服务和XML之间架起一座桥梁。

    JNDI API

    JNDI API由5个包组成：

    l Javax.naming：包含了访问命名服务的类和接口。例如，它定义了Context接口，这是命名服务执行查询的入口。 l Javax.naming.directory：对命名包的扩充，提供了访问目录服务的类和接口。例如，它为属性增加了新的类，提供了表示目录上下文的DirContext接口，定义了检查和更新目录对象的属性的方法。 l Javax.naming.event：提供了对访问命名和目录服务时的时间通知的支持。例如，定义了NamingEvent类，这个类用来表示命名/目录服务产生的事件，定义了侦听NamingEvents的NamingListener接口。 l Javax.naming.ldap：这个包提供了对LDAP 版本3扩充的操作和控制的支持，通用包javax.naming.directory没有包含这些操作和控制。 l Javax.naming.spi：这个包提供了一个方法，通过javax.naming和有关包动态增加对访问命名和目录服务的支持。这个包是为有兴趣创建服务提供者的开发者提供的。

    JNDI 上下文

    正如在前面提到的，命名服务将名称和对象联系起来。这种联系称之为绑定（binding）。一组这样的绑定称之为上下文（context），上下文提供了解析（即返回对象的查找操作）。其他操作包括：名称的绑定和取消绑定，列出绑定的名称。注意到一个上下文对象的名称可以绑定到有同样的命名约定的另一个上下文对象。这称之为子上下文。例如，如果UNIX中目录/home是一个上下文，那么相对于这个目录的子目录就是子上下文？例如，/home/guests中guests就是home的子上下文。在JNDI中，上下文用接口javax.naming.Context表示，这个接口是与命名服务交互的关键接口。在Context（或稍后讨论的DirContext）接口中的每一个命名方法都有两种重载形式：

    Lookup（String name）：接受串名 l
    Lookup（javax.naming.Name）：接受结构名，
    例如，CompositeName（跨越了多个命名系统的名称）或CompondName（单个命名系统中的名称）；它们都实现了Name接口。Compound name的一个例子是：cn=mydir，cn=Q Mahmoud，ou=People，composite name的一个例子是：cn=mydir，cn=Q Mahmoud，ou=People/myfiles/max.txt（这里，myfiles/max.txt是表示第二部分的文件名）

        Javax.naming.InitialContext是实现了Context接口的类。用这个类作为命名服务的入口。为了创建InitialContext对象，构造器以java.util.Hashtable或者是其子类（例如，Properties）的形式设置一组属性。下面给出了一个例子：

    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服务提供者中工厂类（factory class）的名称。Factory负责为其服务创建适当的InitialContext对象。在上面的代码片断中，为文件系统服务提供者指定了工厂类。表1给出了所支持的服务提供者的工厂类。要注意的是文件系统服务提供者的工厂类需要从Sun公司单独下载，J2SE 1.4.x没有包含这些类。

    表1：上下文INITIAL_CONTEXT_FACTORY的值       Name Service Provider Factory
               File System                                                               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的lookup方法：Object obj=contxt.lookup（name）。Lookup方法返回一个对象，这个对象表示的是你想要找的上下文的儿子。
----------------------------------------------------------------------------------------------------------------------------
对jndi总体的理解： jndi(java naming and directory Interface)它提供了一套使用命名和目录服务的接口。用户可以通过它来使用命名和目录服务。就像jdbc一样。jndi包括命名服务和目录服务两部分，其中目录服务包含目录对象directory object，它包含若干属性对象。提供了对属性的很多操作。

命名和目录服务： 命名和目录服务我们一直在使用，如操作系统的文件系统，它给我们提供对文件的操作，查询，添加删除等功能。DNS服务将url同ip地址绑定在了一起。命名和目录系统的最主要的功能是将name和对象绑定。在它的基础之上还提供更多的功能如lookup,search.而且存储的对象是有一定层次结构的。使用这样的服务我们可以对对象更加有效的管理和操作。

命名服务将一个名称映射到一个对象。RMI Registry和CORBA Naming Service都是命名服务。
目录服务也存放对象，但目录服务识别这些对象的相关属性。可以用项目属性来搜索目录。

在20世纪90年代早期，轻量级的目录访问协议（LightWeightDiretoryAccessProtocol，LDAP）被作为一种标准的目录协议被开发出来，JNDI能够访问LDAP。
j2se为jndi提供了5个扩展包：
javax.naming；为访问命名服务提供的api
javax.naming.directory；为访问目录服务提供了基本的接口
javax.naming.event；支持命名和目录服务中的事件通知
javax.naming.ldap； 支持ldap的包，
javax.naming.spi；提供了不同命名和目录服务可以挂接他们的实现的方法。

context: context是一套name-to-object的绑定(bindings),可以理解为层次或目录，它还可已包括下一层subContext。在使用命名和目录服务时获得initial context是对整个名字空间操作的入口。在目录服务中是DirContext.
----------------------------------------------------------------------------------------------------------------------------

JNDI(Java Naming and Directory Interface)是一个应用程序设计的API，为开发人员提供了查找和访问各种命名和目录服务的通用、统一的接口，类似JDBC都是构建在抽象层上。

JNDI可访问的现有的目录及服务有：
DNS、XNam 、Novell目录服务、LDAP(Lightweight Directory Access Protocol 轻型目录访问协议)、 CORBA对象服务、文件系统、Windows XP/2000/NT/Me/9x的注册表、RMI、DSML v1&v2、NIS。

JNDI优点：
包含了大量的命名和目录服务，使用通用接口来访问不同种类的服务；可以同时连接到多个命名或目录服务上；建立起逻辑关联，允许把名称同Java对象或资源关联起来，而不必指导对象或资源的物理ID。

JNDI程序包：
javax.naming：命名操作；
javax.naming.directory：目录操作；
javax.naming.event：在命名目录服务器中请求事件通知；
javax.naming.ldap：提供LDAP支持；
javax.naming.spi：允许动态插入不同实现。

利用JNDI的命名与服务功能来满足企业级APIs对命名与服务的访问，诸如EJBs、JMS、JDBC 2.0以及IIOP上的RMI通过JNDI来使用CORBA的命名服务。

JNDI与JDBC：
JNDI提供了一种统一的方式，可以用在网络上查找和访问服务。通过指定一个资源名称，该名称对应于数据库或命名服务中的一个纪录，同时返回数据库连接建立所必须的信息。
代码示例：
try{
Context cntxt = new InitialContext();
DataSource ds = (DataSource) cntxt.lookup("jdbc/dpt");
}
catch(NamingException ne){
...
}

JNDI与JMS：
消息通信是软件组件或应用程序用来通信的一种方法。JMS就是一种允许应用程序创建、发送、接收、和读取消息的JAVA技术。
代码示例：
try{
Properties env = new Properties();
InitialContext inictxt = new InitialContext(env);
TopicConnectionFactory connFactory = (TopicConnectionFactory) inictxt.lookup("TTopicConnectionFactory");
...
}
catch(NamingException ne){
...
}

访问特定目录：举个例子，人是个对象，他有好几个属性，诸如这个人的姓名、电话号码、电子邮件地址、邮政编码等属性。通过getAttributes()方法
Attribute attr = directory.getAttributes(personName).get("email");
String email = (String)attr.get();
通过使用JNDI让客户使用对象的名称或属性来查找对象：
foxes = directory.search("o=Wiz,c=US", "sn=Fox", controls);

通过使用JNDI来查找诸如打印机、数据库这样的对象，查找打印机的例子：
Printer printer = (Printer)namespace.lookup(printerName);
printer.print(document);

浏览命名空间：
NamingEnumeration list = namespace.list("o=Widget, c=US");
while (list.hasMore()) {
NameClassPair entry = (NameClassPair)list.next();
display(entry.getName(), entry.getClassName());
}

参考资料：
http://java.sun.com/products/jndi/examples.html
http://java.sun.com/products/jndi/serviceproviders.html

常用的JNDI操作：
void bind(String sName,Object object);――绑定：把名称同对象关联的过程
void rebind(String sName,Object object);――重新绑定：用来把对象同一个已经存在的名称重新绑定
void unbind(String sName);――释放：用来把对象从目录中释放出来
void lookup(String sName,Object object);――查找：返回目录总的一个对象
void rename(String sOldName,String sNewName);――重命名：用来修改对象名称绑定的名称
NamingEnumeration listBinding(String sName);――清单：返回绑定在特定上下文中对象的清单列表
NamingEnumeration list(String sName);
代码示例：重新得到了名称、类名和绑定对象。
NamingEnumeration namEnumList = ctxt.listBinding("cntxtName");
...
while ( namEnumList.hasMore() )  {
Binding bnd = (Binding) namEnumList.next();
String sObjName = bnd.getName();
String sClassName = bnd.getClassName();
SomeObject objLocal = (SomeObject) bnd.getObject();
}

----------------------------------------------------------------------------------------------------------------------------

了解名字服务和目录服务的相关概念，有助于更好的使用JNDI。 Naming service       名字服务定义了如何将名字与对象关联，并通过名字如何找到对象的方法。典型的例子如：DNS将域名与IP关联，文件系统将文件名与文件相关联。在名字服务中，主要的概念：

-          名字（Names），在名字系统中实际对象的代号，如文件名，域名等，它会被用来查找关联的对象。不同的系统中会有不同的命名规范，如文件系统采用“\”来表示层级，而DNS则使用“.”。

-          绑定（Bindings），名字和实际对象的关联。

-          引用和地址（References and Addresses），当对象不能直接被存储在名字系统时，就必须使用引用，通过引用找到实际的对象。在系统中，保存的引用的内容被称为地址。引用还有另一个用处：在名字系统中，缺少象关系数据库中外键的概念。通过使用引用，可以作为外键的一个取代办法。

-          上下文（Context），它是一个名字-对象集合，提供了与名字系统交互的主要操作，如查找、绑定、去绑定。子上下文（subcontext）与它的关系类似文件系统中目录和子目录的关系，子上下文被包含在一个上下文中，通过父上下文中的一个名字与子上下文关联。

-          名字系统和名字空间（Naming Systems and Namespaces），名字系统是相同类型的上下文的集合，它提供名字服务；名字空间，是名字系统中的名字集合，如文件系统的文件名和目录。

Directory service       目录服务是名字服务的扩展，它除了关联名字和对象，还允许对象包含属性。目录系统通常以层次结构组织数据。在目录服务中的主要概念：

-          属性（Attributes），它属于目录对象，它是（名字，值）对，属性可以有多个值。

-          目录和目录服务（Directories and Directory Services），目录是目录对象的集合；目录服务则提供与目录相关的服务，创建、删除和修改存放在目录中的对象的属性。

-          查找和查找过滤器（Searches and Search Filters），获取目录对象的操作就是查找；过滤器是类似查找条件的对象。

基本使用
 

²        注册JNDI提供者

在使用JNDI之前，需要先获取JNDI的提供者，并在系统注册它。与JNDI相关的系统属性在javax.naming.Context中定义，常用的属性：

-          java.naming.factory.initial，服务提供者用来创建InitialContext的类名。

-          java.naming.provider.url，用来配置InitialContext的初始url

-          java.naming.factory.object，用来创建name-to-object映射的类，用于NameClassPair和References。

-          java.naming.factory.state，用来创建jndi state的类

对于目录服务，由于一般需要安全设置，还通常使用：

-          java.naming.security.authentication，安全类型，三个值：none，simple或strong。

-          java.naming.security.principal，认证信息。

-          java.naming.security.credentials，证书信息。

-          java.naming.security.protocol，安全协议名。

使用System.setProperty注册，如果程序不显示说明，那么java会在classpath内查找jdni.properties文件来完成注册。jdni.properties例子：

java.naming.factory.initial=com.codeline.db.MockInitialContextFactory

 

 【连接服务】

注册之后，就可以实施服务连接了。对于名字服务由InitialContext开始，目录服务则使用InitialDirContext。它们分别实现了Context和DirContext，这两个接口分别对应名字服务和目录服务的接口，也是JNDI中最重要的两个接口。

连接名字服务：                
System.setProperty(Context.INITIAL_CONTEXT_FACTORY,"
com.sun.jndi.fscontext.FSContextFactory");
InitialContext ctx = new InitialContext();

连接目录服务：
  Hashtable env = new Hashtable();
   env.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.ldap.LdapCtxFactory");
   env.put(Context.PROVIDER_URL, "ldap://myserver.com/");
   env.put(Context.SECURITY_AUTHENTICATION, "simple");
    //登录ldap server需要的用户名
   env.put(Context.SECURITY_PRINCIPAL, "ldapuser");
  //登录ldap server需要的密码
   env.put(Context.SECURITY_CREDENTIALS, "mypassword");
InitialDirContext ctx = new InitialDirContext(env);

 

多服务提供者：如果应用包含多个服务提供者，在连接时略有不同。以名字服务为例
Hashtable env = new Hashtable();
  env.put(Context.INITIAL_CONTEXT_FACTORY,
"com.sun.jndi.rmi.registry.RegistryContextFactory");
  env.put(Context.PROVIDER_URL, "rmi://myserver.com:1099");
  //使用不同的构造函数
InitialContext ctx = new InitialContext(env);
 

【查找对象】

不论名字服务还是目录服务，都是使用lookup来查找对象的。除了可以使用String作为参数之外，lookup还可使用Name接口作为参数。
Greeter greeter = (Greeter)ctx.lookup("SayHello");
如果想要获得上下文中所有的对象名字，就使用lis返回NameClassPair列表。NameClassPair包含对象名字和对象类名。如果想要获得实际的对象实例列表，就使用listBindings，它返回Binding列表。Binding是NameClassPair的子类，它包含对象的实例。
-  list

NamingEnumeration list = ctx.list("awt");
while (list.hasMore()) {
    NameClassPair nc = (NameClassPair)list.next();
    System.out.println(nc);
}

-  listBindings

NamingEnumeration bindings = ctx.listBindings("awt");
while (bindings.hasMore()) {
    Binding bd = (Binding)bindings.next();
    System.out.println(bd.getName() + ": " + bd.getObject());
}
 

【对象绑定】

- 使用bind添加绑定
Fruit fruit = new Fruit("orange");
ctx.bind("favorite", fruit);

- 使用rebind修改绑定
Fruit fruit = new Fruit("lemon");
ctx.rebind("favorite", fruit);

- 使用unbind去除绑定。
ctx.unbind("favorite");
 

【对象改名】

使用rename可以给一个在上下文中的对象改名
ctx.rename("report.txt", "old_report.txt");

- 获取属性

属性相关的接口是Attribute和Attributes，它们都在javax.naming.directory包内。通过DirContext的getAttributes方法就可以获得对象的属性集合，然后使用Attributes的get方法获得对应的属性，最后通过Attribute的get方法就可以获得属性值。

String dn = "uid=me, dc=mycompany, dc=com, ou=customer, o=ExampleApp";
Context user = (Context)ctx.lookup(dn);
//获得所有属性
Attributes attrs = user.getAttributes("");
Attribute test= attrs .get("test");
Object testValue= test.get();
上例中获得的是user的所有属性，在实际使用过程中，考虑网络带宽的影响，可以设置获取要获取的属性列表：

String reqd_attrs = new String[] { "surname", "initials","title", "rfc822mailalias"};
Attributes attrs = user.getAttributes("", reqd_attrs);
 

【查找和过滤】

使用search方法完成。
    public DirContext[] findUser(String initials,String surname,String country,String phone) {
       //构造条件
         BasicAttributes search_attrs = new BasicAttributes();
        search_attrs.put("initials", initials);
        search_attrs.put("sn", surname);
        search_attrs.put("c", country);
       if(phone != null)
          search_attrs.put("phonenumber", phone);
        NamingEnumeration results = initial_ctx.search("ou=Customer,o=ExampleApp", search_attrs);
        LinkedList found = new LinkedList();
        while(results.hasMore()) {
            SearchResults sr = (SearchResults)results.next();
            String name = sr.getName();
            Object ctx = sr.getObject();
           if((ctx == null) || !(ctx instanceof DirContext))
               found.add(initial_ctx.lookup(name));
           else
               found.add(ctx);
       }
       DirContext[] ret_val = new DirContext[found.size()];
        found.toArray(ret_val);
       return ret_val;
  }
 

DirContext接口主要过滤方式：
1.使用过滤字符串
String reqd_attrs = new String[] { "cn", "uid","rfc822mailalias" };
NamingEnumeration results = initial_ctx.search("ou=Customer, o=ExampleApp",search_attrs,reqd_attrs);
 
2.使用SearchControls，获得更多的控制
SearchControls ctrls = new SearchControls();
ctrls.setCountLimit(20);
ctrls.setTimeLimit(5000);
ctrls.setSearchScope(SearchControls.SUBTREE_SCOPE);
NamingEnumeration results = initial_ctx.search("cat=books,ou=Products,
o=ExampleApp","title=*Java*",ctrls);
 【修改属性 】
使用DirContext和InitialDirContext的modifyAttributes方法完成。所谓的修改过程，实际就是先构造要修改的属性列表，然后使用上述方法提交。对于属性包含多个值时，需要把属性的不修改的值也要包含，否则服务器会认为那些值不再需要而删除它们。
 public void updateAddress(String dn,String address, String country, String phone) {
        BasicAttributes mod_attrs = new BasicAttributes();
        if(address != null)
            mod_attrs.put("address", address);
         if(country != null)
             mod_attrs.put("c", country);
        if(phone != null)
             mod_attrs.put("phonenumber", phone);
         if(mod_attrs.size() != 0)
            initial_ctx.modifyAttributes(dn, DirContext.REPLACE_ATTRIBUTE, mod_attrs);
}
使用ModificationItem，也可一次进行多个不同的修改操作：
ModificationItem[] mod_items = new ModificationItems[2];
Attribute email = new BasicAttribute("rfc822mailalias", new_email);
ModificationItem email_mod = new ModificationItem(DirContext.ADD_ATTRIBUTE, email);
Attribute addr = new BasicAttribute("address", address);
ModificationItem addr_mod = new ModificationItem(DirContext.REPLACE_ATTRIBUTE, addr);
mod_items[0] = email_mod;
mod_items[1] = addr_mod;
initial_ctx.modifyAttributes(dn, mod_items);

 【创建上下文】
使用createSubcontext方法完成。
 BasicAttributes attrs = new BasicAttributes();
attrs.put("initials", initials);
 attrs.put("sn", surname);
 attrs.put("rfc822mailalias", email);
 if(address != null)
     attrs.put("address", address);
 if(country != null)
     attrs.put("c", country);
 if(phone != null)
    attrs.put("phonenumber", phone);
initial_ctx.createSubcontext(dn, attrs);
 

【删除上下文】

使用destroySubcontext方法完成。
initial_ctx.destroySubcontext(dn);
 

资料：
jndi学习笔记  http://hankun.blogbus.com/logs/2005/12/1774694.html
 [精华] JNDI   http://www.chinaunix.net/jh/26/30421.html

 

评论

6 楼 StellaAh 2014-03-20  

您好,请教您一个问题, 小弟在学习集成struts2.3.16+spring4+JPA(hibernate4实现)部署时遇到一个问题,几天都没有解决. 谢谢
警告信息如下

2014-03-20 21:44:45,977 WARN  org.hibernate.jpa.boot.archive.internal.JarInputStreamBasedArchiveDescriptor.visitArchive:77 - HHH015010: Unable to find file (ignored): jndi:/localhost/strutsspringjpaexample
java.io.FileNotFoundException: jndi:/localhost/strutsspringjpaexample
	at org.apache.naming.resources.DirContextURLConnection.getInputStream(DirContextURLConnection.java:382)
	at java.net.URL.openStream(URL.java:1031)
	at org.hibernate.jpa.boot.archive.internal.JarInputStreamBasedArchiveDescriptor.visitArchive(JarInputStreamBasedArchiveDescriptor.java:73)
	at org.hibernate.jpa.boot.scan.spi.AbstractScannerImpl.scan(AbstractScannerImpl.java:72)
	at org.hibernate.jpa.boot.internal.EntityManagerFactoryBuilderImpl.scan(EntityManagerFactoryBuilderImpl.java:723)
	at org.hibernate.jpa.boot.internal.EntityManagerFactoryBuilderImpl.<init>(EntityManagerFactoryBuilderImpl.java:219)
	at org.hibernate.jpa.boot.internal.EntityManagerFactoryBuilderImpl.<init>(EntityManagerFactoryBuilderImpl.java:186)
	at org.hibernate.jpa.boot.spi.Bootstrap.getEntityManagerFactoryBuilder(Bootstrap.java:45)
	at org.hibernate.jpa.boot.spi.Bootstrap.getEntityManagerFactoryBuilder(Bootstrap.java:57)
	at org.hibernate.jpa.HibernatePersistenceProvider.createContainerEntityManagerFactory(HibernatePersistenceProvider.java:150)
	at org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean.createNativeEntityManagerFactory(LocalContainerEntityManagerFactoryBean.java:336)
	at org.springframework.orm.jpa.AbstractEntityManagerFactoryBean.afterPropertiesSet(AbstractEntityManagerFactoryBean.java:318)
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.invokeInitMethods(AbstractAutowireCapableBeanFactory.java:1612)
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.initializeBean(AbstractAutowireCapableBeanFactory.java:1549)
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:539)
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:475)
	at org.springframework.beans.factory.support.AbstractBeanFactory$1.getObject(AbstractBeanFactory.java:304)
	at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSingletonBeanRegistry.java:228)
	at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:300)
	at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:195)
	at org.springframework.context.support.AbstractApplicationContext.getBean(AbstractApplicationContext.java:973)
	at org.springframework.context.support.AbstractApplicationContext.finishBeanFactoryInitialization(AbstractApplicationContext.java:750)
	at org.springframework.context.support.AbstractApplicationContext.refresh(AbstractApplicationContext.java:482)
	at org.springframework.web.context.ContextLoader.configureAndRefreshWebApplicationContext(ContextLoader.java:403)
	at org.springframework.web.context.ContextLoader.initWebApplicationContext(ContextLoader.java:306)
	at org.springframework.web.context.ContextLoaderListener.contextInitialized(ContextLoaderListener.java:106)
	at org.apache.catalina.core.StandardContext.listenerStart(StandardContext.java:4701)
	at org.apache.catalina.core.StandardContext$1.call(StandardContext.java:5204)
	at org.apache.catalina.core.StandardContext$1.call(StandardContext.java:5199)
	at java.util.concurrent.FutureTask$Sync.innerRun(FutureTask.java:334)
	at java.util.concurrent.FutureTask.run(FutureTask.java:166)
	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1146)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:615)
	at java.lang.Thread.run(Thread.java:701)

5 楼 need_faith 2014-02-25  

 

4 楼 wupaa246 2013-12-18  

初遇JNDI，看到这篇文章，感觉不错，有空再仔细看看。

3 楼 yds3300376yd 2013-10-30  

看了前半段，受益匪浅，对JNDI有了一个大体的轮廓，多谢楼主。等我进一步学习过后再来看后半段，已收藏之~

2 楼 yinsuxiaokucha 2013-05-09  

  

1 楼 该用户名已经存在 2012-12-17