用共用接口进行客户机编程

文章来源……IBM 中国

介绍

在这一节中，我们将查看两个进行 JMS 客户机消息接发的程序——Sender.java 和 Receiver.java。

Sender：提示输入 JNDI 名

所有示例程序都是命令行程序，它们用 System.in 进行输入，用System.out 进行输出。

Sender 类有两个方法：main(String[]) 和 send()。main(String[]) 方法只是举例说明了 Sender 并调用了它的 send() 方法。 send() 方法的第一部分提示了将用来发送消息的受管理对象的 JNDI 名。

1. import java.io.*;   
2. import javax.jms.*;   
3. import javax.naming.*;   
4.   
5. public class Sender {   
6.   
7.     public static void main(String[] args) {   
8.   
9.         new Sender().send();   
10.     }   
11.   
12.     public void send() {   
13.   
14.         BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));   
15.   
16.         try {   
17.             //Prompt for JNDI names   
18.             System.out.println("Enter ConnectionFactory name:");   
19.             String factoryName = reader.readLine();   
20.             System.out.println("Enter Destination name:");   
21.             String destinationName = reader.readLine();   
22.     . . .   

Sender：查询管理对象

send() 方法的下一部分用前面输入的名字在 JNDI 中查询受管理的对象。Sender：创建 JMS 对象

通过举例说明 InitialContext 对象访问了 JNDI，通过调用 lookup(String) 方法并传递要获取的对象的名字来检索受管理的对象。注意， lookup(String) 方法返回 Object，所以必须对返回的对象进行类型强制转换（typecast）。

java 代码

1. . . .   
2.         //Look up administered objects   
3.         InitialContext initContext = new InitialContext();   
4.         ConnectionFactory factory =   
5.             (ConnectionFactory) initContext.lookup(factoryName);   
6.         Destination destination = (Destination) initContext.lookup(destinationName);   
7.         initContext.close();   
8.         . . .   

 

现在，我们创建了发送消息所需要的 JMS 对象。注意，我们不用直接使用 new 举例说明这些对象。所有对象都是通过调用另一个对象的方法创建的。

首先，用 ConnectionFactory 创建一个 Connection。然后我们用这个 Connection 创建一个 Session。

Session 没有被处理（false） 并且它将使用自动确认（Session.AUTO_ACKNOWLEDGE）。

最后，创建 Sender ，向从 JNDI 中检索的 Destination 发送消息。

java 代码

1. . . .   
2.         //Create JMS objects   
3.         Connection connection = factory.createConnection();   
4.         Session session =   
5.             connection.createSession(false, Session.AUTO_ACKNOWLEDGE);   
6.         MessageProducer sender = session.createProducer(destination);   
7.         . . .   

Sender：发送消息

 

现在我们已经可以发送消息了。在这一部分，我们进入一个循环，它提示了要发送消息的文本。如果用户输入 quit，就可以从循环就退出。

否则要在输入文本中建立一个 TextMessage ，用 MessageProducer 发送消息，然后返回到循环的开始部分。

java 代码

1. . . .   
2.         //Send messages   
3.         String messageText = null;   
4.         while (true) {   
5.             System.out.println("Enter message to send or 'quit':");   
6.             messageText = reader.readLine();   
7.             if ("quit".equals(messageText))   
8.                 break;   
9.             TextMessage message = session.createTextMessage(messageText);   
10.             sender.send(message);   
11.         }   
12.         . . .   

Sender：退出

退出循环后，关闭 Connection。关闭Connection 会自动关闭 Session 和 MessageProducer。

java 代码

1. . . .   
2.         //Exit   
3.         System.out.println("Exiting...");   
4.         reader.close();   
5.         connection.close();   
6.         System.out.println("Goodbye!");   
7.   
8.     } catch (Exception e) {   
9.         e.printStackTrace();   
10.         System.exit(1);   
11.     }   
12. }   

Receiver：提示输入 JNDI 的名称并查找受管理的对象

Receiver 类与 Sender 类非常类似，都有一个 main(String[]) 方法，它只是举例说明了 Receiver 并调用它的主要方法 receive()。

提示输入 JNDI 的名称并查找受管理对象的代码与 Sender 中的代码完全一样。

不过，在这个类中有两处不一样的地方：

• boolean stop 实例变量用来指出程序应该退出。
  
• Receiver 实现了 MessageListener 接口，为了异步接收消息。

java 代码

1. import java.io.*;   
2. import javax.jms.*;   
3. import javax.naming.*;   
4.   
5. public class Receiver implements MessageListener {   
6.   
7.     private boolean stop = false;   
8.   
9.     public static void main(String[] args) {   
10.   
11.         new Receiver().receive();   
12.     }   
13.   
14.     public void receive() {   
15.   
16.         BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));   
17.   
18.         try {   
19.             //Prompt for JNDI names   
20.             System.out.println("Enter ConnectionFactory name:");   
21.             String factoryName = reader.readLine();   
22.             System.out.println("Enter Destination name:");   
23.             String destinationName = reader.readLine();   
24.             reader.close();   
25.   
26.             //Look up administered objects   
27.             InitialContext initContext = new InitialContext();   
28.             ConnectionFactory factory =   
29.                 (ConnectionFactory) initContext.lookup(factoryName);   
30.             Destination destination = (Destination) initContext.lookup(destinationName);   
31.             initContext.close();   
32.             . . .   
33.   

Receiver：创建 JMS 对象

像在 Sender 中那样创建Connection 和 Session，然后创建一个 MessageConsumer。

接着，调用 setMessageListener()，传递 Receiver ——本地实例 this，您会重调用它来实现 MessageListener 接口。

最后，启动 Connection，允许接收消息。

java 代码

1. . . .   
2.         //Create JMS objects   
3.         Connection connection = factory.createConnection();   
4.         Session session =   
5.             connection.createSession(false, Session.AUTO_ACKNOWLEDGE);   
6.         MessageConsumer receiver = session.createConsumer(queue);   
7.         receiver.setMessageListener(this);   
8.         connection.start();   
9.         . . .   

Receiver：等待 stop 并退出

接着，程序进入一个循环，循环会在 stop 变量变为 true 时退出。在循环中，线程睡眠一秒钟。一旦退出循环， Connection 就会关闭，程序会终止。

java 代码

1. . . .   
2.         //Wait for stop   
3.         while (!stop) {   
4.             Thread.sleep(1000);   
5.         }   
6.   
7.         //Exit   
8.         System.out.println("Exiting...");   
9.         connection.close();   
10.         System.out.println("Goodbye!");   
11.   
12.     } catch (Exception e) {   
13.         e.printStackTrace();   
14.         System.exit(1);   
15.     }   
16. }   
17. . . .   

Receiver：onMessage(Message) 方法

需要包含 Receiver 类的 onMessage(Message) 方法，因为 Receiver 可以实现 MessageListener 接口。 收到消息时，就调用这个方法，并将 Message 作为参数传递。

在我们的实现中，我们得到消息的文字内容并将它打印到 System.out。然后检查消息是否等于 stop，如果是，那么就将 stop 变量设置为 true，这会使 receive() 方法中的循环终止。

java 代码

1.     . . .   
2.     public void onMessage(Message message) {   
3.   
4.         try {   
5.             String msgText = ((TextMessage) message).getText();   
6.             System.out.println(msgText);   
7.             if ("stop".equals(msgText))   
8.                 stop = true;   
9.         } catch (JMSException e) {   
10.             e.printStackTrace();   
11.             stop = true;   
12.         }   
13.     }   
14. }   

返回程序

如开始中所述，编译 Sender 和 Receiver 程序需要 javax.naming 和 javax.jms 包。

在运行这个程序之前，需要使用 JMS 提供者提供的管理工具创建受管理对象 ConnectionFactory 和 Destination ，并将它们放到 JNDI 名字空间中。

还需要保证提供者的 JMS 实现类存在于 classpath 中。

然后，可以同时运行这两个程序，为 ConnectionFactory 和 Destination 提供同样的 JNDI 名称，并从 Sender 向 Receiver 发送消息。

最后附上Sender.java 和 Receiver.java

Sender.java

java 代码

1. import java.io.*;   
2. import javax.jms.*;   
3. import javax.naming.*;   
4.   
5. public class Sender {   
6.   
7.     public static void main(String[] args) {   
8.   
9.         new Sender().send();   
10.     }   
11.   
12.     public void send() {   
13.   
14.         BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));   
15.   
16.         try {   
17.             //Prompt for JNDI names   
18.             System.out.println("Enter ConnectionFactory name:");   
19.             String factoryName = reader.readLine();   
20.             System.out.println("Enter Destination name:");   
21.             String destinationName = reader.readLine();   
22.   
23.             //Look up administered objects   
24.             InitialContext initContext = new InitialContext();   
25.             ConnectionFactory factory =   
26.                 (ConnectionFactory) initContext.lookup(factoryName);   
27.             Destination destination = (Destination) initContext.lookup(destinationName);   
28.             initContext.close();   
29.   
30.             //Create JMS objects   
31.             Connection connection = factory.createConnection();   
32.             Session session =   
33.                 connection.createSession(false, Session.AUTO_ACKNOWLEDGE);   
34.             MessageProducer sender = session.createProducer(queue);   
35.   
36.             //Send messages   
37.             String messageText = null;   
38.             while (true) {   
39.                 System.out.println("Enter message to send or 'quit':");   
40.                 messageText = reader.readLine();   
41.                 if ("quit".equals(messageText))   
42.                     break;   
43.                 TextMessage message = session.createTextMessage(messageText);   
44.                 sender.send(message);   
45.             }   
46.   
47.             //Exit   
48.             System.out.println("Exiting...");   
49.             reader.close();   
50.             connection.close();   
51.             System.out.println("Goodbye!");   
52.   
53.         } catch (Exception e) {   
54.             e.printStackTrace();   
55.             System.exit(1);   
56.         }   
57.     }   
58. }  

Receiver.java

java 代码

1. import java.io.*;   
2. import javax.jms.*;   
3. import javax.naming.*;   
4.   
5. public class Receiver implements MessageListener {   
6.   
7.     private boolean stop = false;   
8.   
9.     public static void main(String[] args) {   
10.   
11.         new Receiver().receive();   
12.     }   
13.   
14.     public void receive() {   
15.   
16.         BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));   
17.   
18.         try {   
19.             //Prompt for JNDI names   
20.             System.out.println("Enter ConnectionFactory name:");   
21.             String factoryName = reader.readLine();   
22.             System.out.println("Enter Destination name:");   
23.             String destinationName = reader.readLine();   
24.             reader.close();   
25.   
26.             //Look up administered objects   
27.             InitialContext initContext = new InitialContext();   
28.             ConnectionFactory factory =   
29.                 (ConnectionFactory) initContext.lookup(factoryName);   
30.             Destination destination = (Destination) initContext.lookup(destinationName);   
31.             initContext.close();   
32.   
33.             //Create JMS objects   
34.             Connection connection = factory.createConnection();   
35.             Session session =   
36.                 connection.createSession(false, Session.AUTO_ACKNOWLEDGE);   
37.             MessageConsumer receiver = session.createConsumer(queue);   
38.             receiver.setMessageListener(this);   
39.             connection.start();   
40.   
41.             //Wait for stop   
42.             while (!stop) {   
43.                 Thread.sleep(1000);   
44.             }   
45.   
46.             //Exit   
47.             System.out.println("Exiting...");   
48.             connection.close();   
49.             System.out.println("Goodbye!");   
50.   
51.         } catch (Exception e) {   
52.             e.printStackTrace();   
53.             System.exit(1);   
54.         }   
55.     }   
56.   
57.     public void onMessage(Message message) {   
58.   
59.         try {   
60.             String msgText = ((TextMessage) message).getText();   
61.             System.out.println(msgText);   
62.             if ("stop".equals(msgText))   
63.                 stop = true;   
64.         } catch (JMSException e) {   
65.             e.printStackTrace();   
66.             stop = true;   
67.         }   
68.     }   
69. }   
70.   

 

----------==========================__END__============================================------------------