Java Naming and Directory Interface (JNDI) API 文档

3星 · 超过75%的资源需积分: 10 21 浏览量更新于2024-07-28 收藏 404KB PDF 举报

"JNDI官方文档，包含了Java Naming and Directory Interface (JNDI) 的应用编程接口，适用于JNDI1.2版本和Java 2 Platform, Standard Edition, v1.3。文档由Sun Microsystems, Inc.发布，日期为1999年7月14日。" JNDI（Java Naming and Directory Interface）是Java平台中一个关键的API，它为Java应用程序提供了一种统一的方式来访问命名和目录服务。JNDI的主要目的是解耦应用程序与特定的命名或目录服务之间的依赖，使得开发者能够灵活地使用各种不同的服务，如 Lightweight Directory Access Protocol (LDAP)、DNS、RMI注册表等。 JNDI的核心概念包括： 1. **命名服务**：命名服务允许程序将对象与名字关联起来，从而可以通过名字查找这些对象。在JNDI中，这个名字可以是任意层次的结构化名称，例如“com/mycompany/app/dataSource”。 2. **目录服务**：目录服务扩展了命名服务，允许存储和检索具有属性的对象。在目录服务中，每个条目都有一个唯一的名称，并且可以有多个属性，比如用户账户的用户名、密码、全名等。 3. **上下文（Context）**：JNDI使用Context接口来表示命名或目录服务的一个部分。Context提供了查找、绑定、重新绑定和删除操作的方法，以及对子Context的导航。 4. **查找（Lookup）**：通过调用`lookup()`方法，开发者可以使用JNDI查找与特定名称关联的对象。 5. **绑定（Bind）**：`bind()`方法用于将对象与一个名称关联到命名或目录服务中。 6. **重绑定（Rebind）**：如果一个名称已经绑定到一个对象，`rebind()`方法会替换原有的绑定。 7. **解绑（Unbind）**：`unbind()`方法用于从服务中移除一个名称及其关联的对象。 JNDI还支持多种操作，如迭代遍历目录中的所有条目，以及查询和过滤机制，使开发者可以根据特定的属性或条件进行查找。文档中提到，此版本JNDI API与Java 2 Platform, Standard Edition v1.3兼容，这表明它是针对当时的Java开发环境设计的。值得注意的是，文档还包含版权信息，指出其提供的内容"按原样"提供，不提供任何明示或暗示的保修，包括但不限于适销性、特定用途适用性和非侵权性的保修。此外，文档还提供了技术评论和技术与商业问题的联系方式，分别发送到jndi@java.sun.com和jndi-business@java.sun.com。Sun Microsystems, Inc.的商标如Sun、Sun Microsystems、Java和JavaSoft也在文档中被提及。 JNDI在实际应用中广泛用于配置管理、企业级应用服务器的资源管理，如数据源、邮件服务器配置等。通过JNDI，开发者可以轻松地管理和查找应用所需的资源，而无需硬编码具体的连接字符串或其他敏感信息。

Java Naming and Directory Interface Overview of the Interface

Sun Microsystems, Inc. 9 7/14/99

5 Overview of the Interface

The JNDI API is contained in four packages:

•

javax.naming contains classes and interfaces for accessing naming services

•

javax.naming.directory extends the core javax.naming package to provide access

to directories

•

javax.naming.event contains classes and interfaces for supporting event notification

in naming and directory services

•

javax.naming.ldap contains classes and interfaces for supporting LDAP v3

extensions and controls

The JNDI service provider interface is contained one package:

•

javax.naming.spi contains classes and interfaces that allow various naming and

directory service providers to be dynamically plugged in beneath the JNDI API (see the

JNDI SPI document for details)

The following sections provide an overview of the JNDI API. For more details on the API, see

the corresponding javadoc.

5.1 The Naming Package — javax.naming

5.1.1 Contexts

Context is the core interface that specifies a naming context. It defines basic operations such

as adding a name-to-object binding, looking up the object bound to a specified name, listing

1. See Appendix C for legend of class diagram.

(exception classes are not shown)

java.lang.Object

CompositeName

CompoundName

InitialContext

NameClassPair

Binding

RefAddr

BinaryRefAddr

StringRefAddr

Reference

LinkRef

Name

Context

java.io.Serializable

NamingEnumeration

NameParser

java.lang.Cloneable

Referenceable

Java Naming and Directory Interface Overview of the Interface

Sun Microsystems, Inc. 10 7/14/99

the bindings, removing a name-to-object binding, creating and destroying subcontexts of the

same type, etc.

public interface Context {

public Object lookup(Name name) throws NamingException;

public void bind(Name name, Object obj) throws NamingException;

public void rebind(Name name, Object obj) throws NamingException;

public void unbind(Name name) throws NamingException;

public void rename(Name old, Name new) throws NamingException;

public NamingEnumeration listBindings(Name name)

throws NamingException;

...

public Context createSubcontext(Name name) throws NamingException;

public void destroySubcontext(Name name) throws NamingException;

...

};

Every naming method in Context takes a name as an argument. The operation defined by the

method is performed on the

Context object that is obtained by implicitly resolving the name.

If the name is empty (“”) the operation is performed directly on the context itself. The name of

an object can be a composite name reflecting the arrangement of the namespaces used to refer

to the object. Of course, the client is not exposed to any naming service implementation. In fact,

a new type of naming service can be introduced without requiring the application to be modi-

fied or even disrupted if it is running.

5.1.2 The Initial Context

In JNDI, every name is relative to a context. There is no notion of “absolute names.” An appli-

cation can bootstrap by obtaining its first context of class

InitialContext:

public class InitialContext implements Context {

public InitialContext()...;

...

}

The initial context contains a variety of bindings that hook up the client to useful and shared

contexts from one or more naming systems, such as the namespace of URLs or the root of DNS.

5.1.3 Names

The

Name interface represents a generic name—an ordered sequence of components. Each Con-

text method that takes a Name argument has a counterpart that takes the name as a String in-

stead. The versions using

Name are useful for applications that need to manipulate names:

composing them, comparing components, and so on. The versions using

String are likely to

be more useful for simple applications, such as those that simply read in a name and look up

the corresponding object. The

String name parameter represents a composite name. The Name

parameter can represent a composite name or a compound name.

The

CompositeName class represents a sequence of names (atomic or compound) from multi-

ple namespaces. If the

Name parameter supplied to a method of the Context class is an in-

stance of

CompositeName, the name represents a composite name.

If the

Name parameter supplied to a method of the Context class is not an instance of Compos-

iteName, the name represents a compound name, which can be represented by the Compound-

Java Naming and Directory Interface Overview of the Interface

Sun Microsystems, Inc. 11 7/14/99

Name class or some other implementation class. The CompoundName class represents

hierarchical names from a single namespace. A context’s name parser can be used to manipu-

late compound names in the syntax associated with that particular context:

public interface Context {

...

public NameParser getNameParser(Name name) throws NamingException;

...

}

A namespace browser is an example of the kind of application that might need to manipulate

names syntactically at this level. Most other applications will work with strings or composite

names.

5.1.4 Bindings

Context.lookup() is the most commonly used operation. The context implementation can re-

turn an object of whatever class is required by the Java application. For example, a client might

use the name of a printer to look up the corresponding

Printer object, and then print to it di-

rectly:

Printer printer = (Printer) ctx.lookup(“treekiller”);

printer.print(report);

Context.listBindings() returns an enumeration of name-to-object bindings, each binding

represented by an object of class

Binding. A binding is a tuple containing the name of the

bound object, the name of the object’s class, and the object itself.

The

Context.list() method is similar to listBindings(), except that it returns an enumer-

ation of

NameClassPair objects. Each NameClassPair contains an object’s name and the

name of the object’s class. The

list() method is useful for applications such as browsers that

wish to discover information about the objects bound within a context, but don’t need all of the

actual objects. Although

listBindings() provides all of the same information, it is poten-

tially a much more expensive operation.

public class NameClassPair ... {

public String getName() ...;

public String getClassName() ...;

...

}

public class Binding extends NameClassPair {

public Object getObject() ...;

...

}

5.1.5 References

Different

Context implementations are able to bind different kinds of objects natively. A par-

ticularly useful object that should be supported by any general-purpose context implementation

is the

Reference class. A reference represents an object that exists outside of the directory.

References are used to give JNDI clients the illusion that objects of arbitrary classes are able

to be bound in naming or directory services—such as X.500—that do not have native support

for objects in the Java programming language.

Java Naming and Directory Interface Overview of the Interface

Sun Microsystems, Inc. 12 7/14/99

When the result of an operation such as Context.lookup() or Binding.getObject() is a

Reference object, JNDI attempts to convert the reference into the object that it represents be-

fore returning it to the client. A particularly significant instance of this occurs when a reference

representing a

Context of one naming system is bound to a name in a different naming system.

This is how multiple independent naming systems are joined together into the JNDI composite

namespace. Details of how this mechanism operates are provided in the JNDI SPI document.

Objects that are able to be represented by a reference should implement the

Referenceable

interface. Its single method — getReference() — returns the object’s reference. When such

an object is bound to a name in any context, the context implementation might store the refer-

ence in the underlying system if the object itself cannot be stored natively.

Each reference may contain the name of the class of the object that it represents, and may also

contain the location (typically a URL) where the class file for that object can be found. In ad-

dition, a reference contains a sequence of objects of class

RefAddr. Each RefAddr in turn con-

tains a “type” string and some addressing data, generally a string or a byte array.

A specialization of

Reference called a LinkRef is used to add “symbolic” links into the JNDI

namespace. It contains the name of a JNDI object. By default, these links are followed when-

ever JNDI names are resolved.

5.1.6 Referrals

Some naming/directory services support the notion of referrals for redirecting a client’s re-

quest to another server. The JNDI client can request that referrals be automatically followed,

be ignored, or be processed manually.

The abstract class

ReferralException is used to represent a referral:

public abstract class ReferralException extends NamingException {

public abstract Context getReferralContext()

throws NamingException;

...

public abstract Object getReferralInfo();

public abstract void retryReferral();

public abstract boolean skipReferral();

}

When a referral is encountered and the client has requested that referrals not be ignored or au-

tomatically followed, a

ReferralException is thrown. The getReferralInfo() method pro-

vides information—in a format appropriate to the service provider—about where the referral

leads. The application is not required to examine this information; however, it might choose to

present it to a human user to help him determine whether to follow the referral or not.

skipRe-

ferral() allows the application to discard a referral and continue to the next referral (if any).

To continue the operation, the application re-invokes the method on the referral context using

the same arguments it supplied to the original method.

剩余75页未读，继续阅读

yuan_ping_an

粉丝: 8
资源: 99

Java Naming and Directory Interface (JNDI) API 文档

JNDI学习文档.doc

JNDI文档教程

jndi连接池帮助文档

jndi jndi jndi

JNDIDemo 以及相关文档

jndi配置

tomcat6.0官方文档文档

jndi 反射 耦合

JNDI配置文件

JNDI and OpenLDAP

最新资源

jndi 反射耦合