jndi step by step (3) 命名服务的操作

命名服务的操作

1、寻找一个对象
  
   为了从命名服务中找到一个对象，你可以使用 Context.lookup() 方法，只要传递给它你要寻找的对象的名字就可以。例如，在当前的
命名服务中，有一个对象的名字是“report.txt”，为了找到这个对象，你可以使用
   Object obj = ctx.lookup("report.txt");
   lookup 返回的对象类型，依据你的实际情况来看。命名系统里可以保存各种类型的对象，在这个例子中，“report.txt”返回的对象
因该是文件系统的一个对象(java.io.File) ，你可以进行强制转换：

java 代码

1. import java.io.File;   
2.    ...   
3. File f = (File)ctx.lookup("report.txt");  

下面是这个例子的完整代码：

java 代码

1. import javax.naming.*;   
2. import java.io.File;   
3. import java.util.Hashtable;   
4.   
5. /**  
6.   * Demonstrates how to look up an object.  
7.   *  
8.   * usage: java Lookup  
9.   */  
10. class Lookup {   
11.     public static void main(String[] args) {   
12.   
13.     // Set up the environment for creating the initial context   
14.     Hashtable env = new Hashtable(11);   
15.     env.put(Context.INITIAL_CONTEXT_FACTORY,    
16.         "com.sun.jndi.fscontext.RefFSContextFactory");   
17.     env.put(Context.PROVIDER_URL, "file:/tmp/tutorial");   
18.   
19.     try {   
20.         // Create the initial context   
21.         Context ctx = new InitialContext(env);   
22.   
23.         // Perform lookup and cast to target type   
24.         File f = (File) ctx.lookup("report.txt");   
25.   
26.         System.out.println(f);   
27.   
28.         // Close the context when we're done   
29.         ctx.close();   
30.     } catch (NamingException e) {   
31.         System.out.println("Lookup failed: " + e);   
32.     }   
33.     }   
34. }  

 

2、显示内容上下文列表

   使用 Context.lookup() 方法，你可以得到指定的对象，实际上你还可以通过其他方法来得到内容上下文里的全部对象的列表。你可以
通过2个方法来实现这个目的，其中一个返回绑定(binding)的列表，另一个仅仅返回“名字－－类名”成对的列表。
  
   2.1、Context.List() 方法
   Context.List() 方法返回一个 NameClassPair 类的对象的枚举，枚举中的每一个 NameClassPair 对象，都是由对象的名字和对象的类
名组成的。下面的代码片段，演示了“awt”目录的内容上下文的列表。

java 代码

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

    输出结果就是：
# java List
accessibility: javax.naming.Context
color: javax.naming.Context
datatransfer: javax.naming.Context
dnd: javax.naming.Context
event: javax.naming.Context
font: javax.naming.Context
geom: javax.naming.Context
im: javax.naming.Context
image: javax.naming.Context
peer: javax.naming.Context
print: javax.naming.Context
swing: javax.naming.Context

   2.2、Context.listBindings() 方法
   Context.listBindings() 方法返回一个 Bingding 类的对象的枚举，Binding 类是 NameClassPair 类的之类。一个 Binding 对象，不仅仅包含对象的名字，对象的类名，还包含一个对象。下慢的代码片段演示了这个方法的功能：

java 代码

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

 

   输出结果：

# java ListBindings
accessibility: com.sun.jndi.fscontext.RefFSContext@1dacd52e
color: com.sun.jndi.fscontext.RefFSContext@1dacd551
datatransfer: com.sun.jndi.fscontext.RefFSContext@1dacd584
dnd: com.sun.jndi.fscontext.RefFSContext@1dacd5b6
event: com.sun.jndi.fscontext.RefFSContext@1dacd5e8
font: com.sun.jndi.fscontext.RefFSContext@1dacd61b
geom: com.sun.jndi.fscontext.RefFSContext@1dacd64d
im: com.sun.jndi.fscontext.RefFSContext@1dacd62a
image: com.sun.jndi.fscontext.RefFSContext@1dacd65c
peer: com.sun.jndi.fscontext.RefFSContext@1dacd68f
print: com.sun.jndi.fscontext.RefFSContext@1dacd6c1
swing: com.sun.jndi.fscontext.RefFSContext@1dacd6f3

   2.3、如何停止一个枚举的循环

   NamingEnumeration 类可以以三种方式来终止循环：自然的，显示的，异常方式。
   a) 当  NamingEnumeration.hasMore() 返回 false，枚举就自动终止了。
   b) 可以使用 NamingEnumeration.close() 来强行终止一个循环，但是记得要释放其中的资源。
   c) 如果你抛出一个 NamingException ，那么循环也会被终止。

   不管枚举是如何被终止的，一旦它被终止了，那么就不要再使用这个变量。否则会发生不确定的错误。

   2.4、为什么我们会需要这2个方法？

   list() 方法是为浏览器风格的应用而准备的，因为这种应用一般仅仅要求现实对象的名字。例如，浏览器
   会显示一个内容上下文里的全部对象的名字，然后让用户去选择，以进行下一步操作。一般这样的应用没必要
   访问内容上下文里的具体对象。

   listBindings() 方法是为一些会操作内容上下文里的对象的应用而准备的。例如，一个后台程序可能会查看
   某一个目录里的全部文件的状态。或者一个打印机管理程序会重新启动全部的打印机。为了执行类似的操作，
   应用程序必须得到内容上下文里的具体对象，因此，用这个方法就显得特别有效了。

   这两个方法，你可以根据实际的情况来选择使用。

3、添加、修改、删除一个绑定(Binding)

   Context 借口有一些针对binding的操作方法：adding, replacing, 和 removing。
  
   3.1、增加一个binding

   Context.bind() 方法可以给内容上下文增加一个binding，可以给传入两个参数：一个是对象的名字，另一个
   是对象。

java 代码

1. // Create the object to be bound   
2. Fruit fruit = new Fruit("orange");   
3.   
4. // Perform the bind   
5. ctx.bind("favorite", fruit);  

    下面用代码演示了这个方法的使用：

java 代码

1. FruitFactory.java :   
2.   
3. import javax.naming.*;   
4. import javax.naming.spi.ObjectFactory;   
5. import java.util.Hashtable;   
6.   
7. /**  
8.  * This is an object factory that when given a reference for a Fruit  
9.  * object, will create an instance of the corresponding Fruit.  
10.  */  
11. public class FruitFactory implements ObjectFactory {   
12.     public FruitFactory() {   
13.     }   
14.   
15.     public Object getObjectInstance(Object obj, Name name, Context ctx,   
16.     Hashtable env) throws Exception {   
17.     if (obj instanceof Reference) {   
18.         Reference ref = (Reference)obj;   
19.         if (ref.getClassName().equals(Fruit.class.getName())) {   
20.         RefAddr addr = ref.get("fruit");   
21.         if (addr != null) {   
22.             return new Fruit((String)addr.getContent());   
23.         }   
24.         }   
25.     }   
26.     return null;   
27.     }   
28. }   
29.   
30.   
31. Fruit.java:   
32.   
33. import javax.naming.*;   
34.   
35. /**  
36.   * This class is used by the Bind example.  
37.   * It is a referenceable class that can be stored by service  
38.   * providers like the LDAP and file system providers.  
39.   */  
40. public class Fruit implements Referenceable {   
41.     String fruit;   
42.        
43.     public Fruit(String f) {   
44.     fruit = f;   
45.     }   
46.        
47.     public Reference getReference() throws NamingException {   
48.     return new Reference(   
49.         Fruit.class.getName(),   
50.         new StringRefAddr("fruit", fruit),   
51.         FruitFactory.class.getName(),   
52.         null);          // factory location   
53.     }   
54.   
55.     public String toString() {   
56.     return fruit;   
57.     }   
58. }   
59.   
60. main class:   
61.   
62. import javax.naming.*;   
63. import java.io.File;   
64. import java.util.Hashtable;   
65.   
66. /**  
67.   * Demonstrates how to add a binding to a context.  
68.   * (Use Rebind example to overwrite binding; use Unbind to remove binding.)  
69.   *  
70.   * usage: java Bind  
71.   */  
72.   
73. class Bind {   
74.     public static void main(String[] args) {   
75.   
76.     // Set up the environment for creating the initial context   
77.     Hashtable env = new Hashtable(11);   
78.     env.put(Context.INITIAL_CONTEXT_FACTORY,    
79.         "com.sun.jndi.fscontext.RefFSContextFactory");   
80.     env.put(Context.PROVIDER_URL, "file:/tmp/tutorial");   
81.   
82.     try {   
83.         // Create the initial context   
84.         Context ctx = new InitialContext(env);   
85.   
86.         // Create the object to be bound   
87.         Fruit fruit = new Fruit("orange");   
88.   
89.         // Perform the bind   
90.         ctx.bind("favorite", fruit);   
91.   
92.         // Check that it is bound   
93.         Object obj = ctx.lookup("favorite");   
94.         System.out.println(obj);   
95.   
96.         // Close the context when we're done   
97.         ctx.close();   
98.     } catch (NamingException e) {   
99.         System.out.println("Operation failed: " + e);   
100.     }   
101.     }   
102. }  

 

    如果你运行两次这个例子，那么会遇到一个错误：NameAlreadyBoundException。这是因为在内容上下文里
    不能有重复名字的对象。如果你想运行两次，那么就需要使用 rebind() 方法。

    3.2、增加或替换一个binding

    rebind()方法是用来增加或者替换一个binding。参数和 bind() 方法一样，不同的是，如果内容上下文里
    已经存在了同名的对象，那么就会用新的对象把旧的对象替换掉。

java 代码

1. // Create the object to be bound   
2. Fruit fruit = new Fruit("lemon");   
3.   
4. // Perform the bind   
5. ctx.rebind("favorite", fruit);   

 

    3.3、删除一个binding

    你可以使用 unbind() 方法来删除一个绑定。

java 代码

1. // Remove the binding   
2. ctx.unbind("favorite");  

 

4、重新命名一个对象

   你可以使用 Context.rename() 方法来重新命名一个对象。

java 代码

1. // Rename to old_report.txt   
2. ctx.rename("report.txt", "old_report.txt");  

 

5、创建和删除一个子内容上下文

   Context 接口里有两个方法可以创建和删除子内容上下文。如果是对于文件系统来说，那就是创建和删除一个
   子目录。
  
   5.1、创建一个内容上下文
  
   你可以使用 createSubcontext() 方法来创建一个子内容上下文。

java 代码

1. // Create the context   
2. Context result = ctx.createSubcontext("new");  

   下面是一个例子：

java 代码

1. import javax.naming.*;   
2. import java.io.File;   
3. import java.util.Hashtable;   
4.   
5. /**  
6.   * Demonstrates how to create a new subcontext called "new".  
7.   * (Run Destroy after this to remove the subcontext).  
8.   *  
9.   * usage: java Create  
10.   */  
11. class Create {   
12.     public static void main(String[] args) {   
13.   
14.     // Set up the environment for creating the initial context   
15.     Hashtable env = new Hashtable(11);   
16.     env.put(Context.INITIAL_CONTEXT_FACTORY,    
17.         "com.sun.jndi.fscontext.RefFSContextFactory");   
18.     env.put(Context.PROVIDER_URL, "file:/tmp/tutorial");   
19.   
20.     try {   
21.         // Create the initial context   
22.         Context ctx = new InitialContext(env);   
23.   
24.         // Create the context   
25.         Context result = ctx.createSubcontext("new");   
26.   
27.         // Check that it was created by listing its parent   
28.         NamingEnumeration list = ctx.list("");   
29.   
30.         // Go through each item in list   
31.         while (list.hasMore()) {   
32.         NameClassPair nc = (NameClassPair)list.next();   
33.         System.out.println(nc);   
34.         }   
35.   
36.         // Close the context when we're done   
37.         ctx.close();   
38.     } catch (NamingException e) {   
39.         System.out.println("Create failed: " + e);   
40.     }   
41.     }   
42. }  

 

    5.2、删除一个上下文
  
    你可以使用 destroySubcontext() 来删除一个内容上下文。

java 代码

1. // Destroy the context   
2. ctx.destroySubcontext("new");  

下面是一个例子：

java 代码

1. import javax.naming.*;   
2. import java.io.File;   
3. import java.util.Hashtable;   
4.   
5. /**  
6.   * Demonstrates how to destroy a subcontext called "new".  
7.   * (Run this after running Create)  
8.   *  
9.   * usage: java Destroy  
10.   */  
11. class Destroy {   
12.     public static void main(String[] args) {   
13.   
14.     // Set up the environment for creating the initial context   
15.     Hashtable env = new Hashtable(11);   
16.     env.put(Context.INITIAL_CONTEXT_FACTORY,    
17.         "com.sun.jndi.fscontext.RefFSContextFactory");   
18.     env.put(Context.PROVIDER_URL, "file:/tmp/tutorial");   
19.   
20.     try {   
21.         // Create the initial context   
22.         Context ctx = new InitialContext(env);   
23.   
24.         // Destroy the context   
25.         ctx.destroySubcontext("new");   
26.   
27.         // Check that it has been destroyed by listing its parent   
28.         NamingEnumeration list = ctx.list("");   
29.   
30.         // Go through each item in list   
31.         while (list.hasMore()) {   
32.         NameClassPair nc = (NameClassPair)list.next();   
33.         System.out.println(nc);   
34.         }   
35.   
36.         // Close the context when we're done   
37.         ctx.close();   
38.     } catch (NamingException e) {   
39.         System.out.println("destroy failed: " + e);   
40.     }   
41.     }   
42. }