设为首页收藏本站
开启辅助访问

在路上

 找回密码
 立即注册
在路上 › 站点首页 ›学习 › 查看内容

Java中的命名与目录接口JNDI基本操作方法概览

2016-8-29 13:20| 发布者: zhangjf| 查看: 542| 评论: 0

摘要: 对jndi总体的理解： jndi(java naming and directory Interface)它提供了一套使用命名和目录服务的接口。用户可以通过它来使用命名和目录服务。就像jdbc一样。jndi包括命名服务和目录服务两部分，其中目录服务包含目 ...

对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提供了一种统一的方式，可以用在网络上查找和访问服务。通过指定一个资源名称，该名称对应于数据库或命名服务中的一个纪录，同时返回数据库连接建立所必须的信息。
代码示例：

  2. try{
  3. Context cntxt = new InitialContext();
  4. DataSource ds = (DataSource) cntxt.lookup("jdbc/dpt");
  5. }
  6. catch(NamingException ne){
  7. ...
  8. }
复制代码

JNDI与JMS：
消息通信是软件组件或应用程序用来通信的一种方法。JMS就是一种允许应用程序创建、发送、接收、和读取消息的JAVA技术。
代码示例：

  2. try{
  3. Properties env = new Properties();
  4. InitialContext inictxt = new InitialContext(env);
  5. TopicConnectionFactory connFactory = (TopicConnectionFactory) inictxt.lookup("TTopicConnectionFactory");
  6. ...
  7. }
  8. catch(NamingException ne){
  9. ...
  10. }
复制代码

访问特定目录：举个例子，人是个对象，他有好几个属性，诸如这个人的姓名、电话号码、电子邮件地址、邮政编码等属性。通过getAttributes()方法

  2. Attribute attr = directory.getAttributes(personName).get("email");
  3. String email = (String)attr.get();
复制代码

通过使用JNDI让客户使用对象的名称或属性来查找对象：

  2. foxes = directory.search("o=Wiz,c=US", "sn=Fox", controls);
复制代码

通过使用JNDI来查找诸如打印机、数据库这样的对象，查找打印机的例子：

  2. Printer printer = (Printer)namespace.lookup(printerName);
  3. printer.print(document);
复制代码

浏览命名空间：

  2. NamingEnumeration list = namespace.list("o=Widget, c=US");
  3. while (list.hasMore()) {
  4. NameClassPair entry = (NameClassPair)list.next();
  5. display(entry.getName(), entry.getClassName());
  6. }
复制代码
  • 常用的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);

代码示例：重新得到了名称、类名和绑定对象。

  2. NamingEnumeration namEnumList = ctxt.listBinding("cntxtName");
  3. ...
  4. while ( namEnumList.hasMore() ) {
  5. Binding bnd = (Binding) namEnumList.next();
  6. String sObjName = bnd.getName();
  7. String sClassName = bnd.getClassName();
  8. SomeObject objLocal = (SomeObject) bnd.getObject();
  9. }
复制代码

了解名字服务和目录服务的相关概念，有助于更好的使用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），获取目录对象的操作就是查找；过滤器是类似查找条件的对象。
基本使用

2 注册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中最重要的两个接口。
连接名字服务：

  2. System.setProperty(Context.INITIAL_CONTEXT_FACTORY,"
  3. com.sun.jndi.fscontext.FSContextFactory");
  4. InitialContext ctx = new InitialContext();
复制代码

连接目录服务：

  2. Hashtable env = new Hashtable();
  3. env.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.ldap.LdapCtxFactory");
  4. env.put(Context.PROVIDER_URL, "ldap://myserver.com/");
  5. env.put(Context.SECURITY_AUTHENTICATION, "simple");
  6. //登录ldap server需要的用户名
  7. env.put(Context.SECURITY_PRINCIPAL, "ldapuser");
  8. //登录ldap server需要的密码
  9. env.put(Context.SECURITY_CREDENTIALS, "mypassword");
  10. InitialDirContext ctx = new InitialDirContext(env);
复制代码


多服务提供者：如果应用包含多个服务提供者，在连接时略有不同。以名字服务为例

  2. Hashtable env = new Hashtable();
  3. env.put(Context.INITIAL_CONTEXT_FACTORY,
  4. "com.sun.jndi.rmi.registry.RegistryContextFactory");
  5. env.put(Context.PROVIDER_URL, "rmi://myserver.com:1099");
  6. //使用不同的构造函数
  7. InitialContext ctx = new InitialContext(env);
复制代码


查找对象
不论名字服务还是目录服务，都是使用lookup来查找对象的。除了可以使用String作为参数之外，lookup还可使用Name接口作为参数。

  2. Greeter greeter = (Greeter)ctx.lookup("SayHello");
复制代码

如果想要获得上下文中所有的对象名字，就使用lis返回NameClassPair列表。NameClassPair包含对象名字和对象类名。如果想要获得实际的对象实例列表，就使用listBindings，它返回Binding列表。Binding是NameClassPair的子类，它包含对象的实例。
- list

  2. NamingEnumeration list = ctx.list("awt");
  3. while (list.hasMore()) {
  4. NameClassPair nc = (NameClassPair)list.next();
  5. System.out.println(nc);
  6. }
复制代码

- listBindings

  2. NamingEnumeration bindings = ctx.listBindings("awt");
  3. while (bindings.hasMore()) {
  4. Binding bd = (Binding)bindings.next();
  5. System.out.println(bd.getName() + ": " + bd.getObject());
  6. }
复制代码


对象绑定
- 使用bind添加绑定

  2. Fruit fruit = new Fruit("orange");
  3. ctx.bind("favorite", fruit);
复制代码

- 使用rebind修改绑定

  2. Fruit fruit = new Fruit("lemon");
  3. ctx.rebind("favorite", fruit);
复制代码

- 使用unbind去除绑定。

  2. ctx.unbind("favorite");
复制代码


对象改名
使用rename可以给一个在上下文中的对象改名

  2. ctx.rename("report.txt", "old_report.txt");
复制代码

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

  2. String dn = "uid=me, dc=mycompany, dc=com, ou=customer, o=ExampleApp";
  3. Context user = (Context)ctx.lookup(dn);
  4. //获得所有属性
  5. Attributes attrs = user.getAttributes("");
  6. Attribute test= attrs .get("test");
  7. Object testValue= test.get();
复制代码

上例中获得的是user的所有属性，在实际使用过程中，考虑网络带宽的影响，可以设置获取要获取的属性列表：

  2. String reqd_attrs = new String[] { "surname", "initials","title", "rfc822mailalias"};
  3. Attributes attrs = user.getAttributes("", reqd_attrs);
复制代码


查找和过滤
使用search方法完成。

  2. public DirContext[] findUser(String initials,String surname,String country,String phone) {
  3. //构造条件
  4. BasicAttributes search_attrs = new BasicAttributes();
  5. search_attrs.put("initials", initials);
  6. search_attrs.put("sn", surname);
  7. search_attrs.put("c", country);
  8. if(phone != null)
  9. search_attrs.put("phonenumber", phone);
  10. NamingEnumeration results = initial_ctx.search("ou=Customer,o=ExampleApp", search_attrs);
  11. LinkedList found = new LinkedList();
  12. while(results.hasMore()) {
  13. SearchResults sr = (SearchResults)results.next();
  14. String name = sr.getName();
  15. Object ctx = sr.getObject();
  16. if((ctx == null) || !(ctx instanceof DirContext))
  17. found.add(initial_ctx.lookup(name));
  18. else
  19. found.add(ctx);
  20. }
  21. DirContext[] ret_val = new DirContext[found.size()];
  22. found.toArray(ret_val);
  23. return ret_val;
  24. }
复制代码


DirContext接口主要过滤方式：
1.使用过滤字符串

  2. String reqd_attrs = new String[] { "cn", "uid","rfc822mailalias" };
  3. NamingEnumeration results = initial_ctx.search("ou=Customer, o=ExampleApp",search_attrs,reqd_attrs);
复制代码


2.使用SearchControls，获得更多的控制

  2. SearchControls ctrls = new SearchControls();
  3. ctrls.setCountLimit(20);
  4. ctrls.setTimeLimit(5000);
  5. ctrls.setSearchScope(SearchControls.SUBTREE_SCOPE);
  6. NamingEnumeration results = initial_ctx.search("cat=books,ou=Products,
  7. o=ExampleApp","title=*Java*",ctrls);
复制代码

修改属性
使用DirContext和InitialDirContext的modifyAttributes方法完成。所谓的修改过程，实际就是先构造要修改的属性列表，然后使用上述方法提交。对于属性包含多个值时，需要把属性的不修改的值也要包含，否则服务器会认为那些值不再需要而删除它们。

  2. public void updateAddress(String dn,String address, String country, String phone) {
  3. BasicAttributes mod_attrs = new BasicAttributes();
  4. if(address != null)
  5. mod_attrs.put("address", address);
  6. if(country != null)
  7. mod_attrs.put("c", country);
  8. if(phone != null)
  9. mod_attrs.put("phonenumber", phone);
  10. if(mod_attrs.size() != 0)
  11. initial_ctx.modifyAttributes(dn, DirContext.REPLACE_ATTRIBUTE, mod_attrs);
  12. }
复制代码

使用ModificationItem，也可一次进行多个不同的修改操作：

  2. ModificationItem[] mod_items = new ModificationItems[2];
  3. Attribute email = new BasicAttribute("rfc822mailalias", new_email);
  4. ModificationItem email_mod = new ModificationItem(DirContext.ADD_ATTRIBUTE, email);
  5. Attribute addr = new BasicAttribute("address", address);
  6. ModificationItem addr_mod = new ModificationItem(DirContext.REPLACE_ATTRIBUTE, addr);
  7. mod_items[0] = email_mod;
  8. mod_items[1] = addr_mod;
  9. initial_ctx.modifyAttributes(dn, mod_items);
复制代码

创建上下文
使用createSubcontext方法完成。

  2. BasicAttributes attrs = new BasicAttributes();
  3. attrs.put("initials", initials);
  4. attrs.put("sn", surname);
  5. attrs.put("rfc822mailalias", email);
  6. if(address != null)
  7. attrs.put("address", address);
  8. if(country != null)
  9. attrs.put("c", country);
  10. if(phone != null)
  11. attrs.put("phonenumber", phone);
  12. initial_ctx.createSubcontext(dn, attrs);
复制代码


删除上下文
使用destroySubcontext方法完成。

  2. initial_ctx.destroySubcontext(dn);
复制代码

实例
以下再举一个实例。

在tomcat的conf/server.xml中配置：

  2. <Context path="/jndi">
  4. <Resource name="bean/MyBeanFactory" auth="Container"
  5. type="com.huawei.jndi.bean.MyBean"
  6. factory="org.apache.naming.factory.BeanFactory"
  7. bar="23"/>
  9. </Context>
复制代码

上面就在tomcat中声明了一个组件，接下来在代码中可以获取这个组件：

  2. try
  3. {
  4. Context initContext = new InitialContext();
  5. Context envCtx = (Context) initContext.lookup("java:comp/env");
  6. MyBean bean = (MyBean) envCtx.lookup("bean/MyBeanFactory");
  7. System.out.println(bean.getBar());
  8. }
  9. catch (Exception e)
  10. {
  11. e.printStackTrace();
  12. }
复制代码

总结：在tomcat中配置jndi组件，然后在代码中获取已配好的组件。

各WEB容器的JNDI实现类是不同的，比如在JBOSS中，JNDI提供类是org.jnp.interfaces.NamingContextFactory，与tomcat是不同的。

这样看来，JNDI的作用和spring的依赖注入倒是差不多。但是通过JNDI，可以实现跨应用，甚至跨域获取组件。在服务器A上配置的组件，在另一台服务器B上，可以通过JNDI获取到。

spring也提供了对jndi的封装，使用起来更加方便，以下是一个例子。

  2. <!-- JNDI模板 -->
  3. <bean id="jndiTemplate" class="org.springframework.jndi.JndiTemplate">
  4. <property name="environment">
  5. <props>
  6. <prop key="java.naming.factory.initial">org.jnp.interfaces.NamingContextFactory</prop>
  7. <prop key="java.naming.provider.url">10.137.96.212:18199</prop>
  8. <prop key="java.naming.factory.url.pkgs">org.jnp.interfaces:org.jboss.naming</prop>
  9. </props>
  10. </property>
  11. </bean>
  13. <!-- 创建连接工厂 -->
  14. <bean id="jmsConnectionFactory" class="org.springframework.jndi.JndiObjectFactoryBean">
  15. <property name="jndiTemplate" ref="jndiTemplate" />
  16. <property name="jndiName" value="TopicConnectionFactory" />
  17. </bean>
复制代码

先声明JndiTemplate，配置好目标地址、JNDI服务提供类。然后通过JndiObjectFactoryBean，就可以很方便地获取JNDI组件，并进行类型转换。

收藏 邀请
上一篇：详解Java Spring各种依赖注入注解的区别下一篇：Java ArrayDeque实现Stack的功能

最新评论

相关分类

小黑屋|在路上 ( 蜀ICP备15035742号-1 )  

;

GMT+8, 2025-7-7 02:45

Copyright 2015-2025 djqfx

返回顶部