`

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

    博客分类：
  • JMS
编程JMSJavaUPIBM 
阅读更多

文章来源……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__============================================------------------

分享到：
| JMS 1.1 中的新内容：共用接口
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    《IOT-WL210CB-CP空压机专用无线中继模块用户手册》.pdf

    3. 通讯及逻辑可编程功能：用户可以应用Autoshop软件通过USB接口对模块进行编程设置，可以修改通讯协议及逻辑控制等。 4. 掉电上报功能：当设备外部供电中断后，设备自动上报掉电事件到指定服务器，并保存该事件到...

    2014大学Windows网络编程(机械工业出版社)-课后习题解答.docx

    - **设计方法**：使用WinPcap或WinSock编程中的原始套接字来实现数据捕获。 - **主要流程**： 1. 通过交换机的镜像端口或分光器获取局域网中的网络流量。 2. 捕获并存储这些流量数据。 3. 对捕获的数据进行过滤，...

    2021-2022计算机二级等级考试试题及答案No.5250.docx

    8. 客户机/服务器结构：在C/S架构中，客户机是发起请求的一方，服务器则是处理请求的一方。 9. SQL查询：在SQL查询中，使用And运算符可以指定范围查询，如B选项所示，可以找出60到80分之间（包括60分）的成绩。 10...

    W5500数据手册

    这表示用户可以在他们的应用中使用单芯片实现以太网应用，通过简单的Socket编程就能完成。 W5500内部集成了32K字节的片上缓存，支持8个硬件Socket进行独立通讯，这使得W5500能够同时处理多个网络连接任务。用户可以...

    Teradata 数据仓库基础

    - **TERADATA数据库的编程接口**：介绍Teradata数据库提供的编程接口，包括调用层接口CLI、嵌入式预处理器和ODBC等。 - **TERADATA应用工具**：提供了一系列应用工具，如BTEQ、FastLoad、MultiLoad、FastExport和...

    C++MFC教程

    2、开发注重交互的简单应用程序可以使用对话框为基础的窗口，如果文件读写简单这可利用CFile进行。 3、开发注重交互并且文件读写复杂的的简单应用程序可以利用以CFormView为基础视的单文档视结构。 4、利用对话框...

    ROS机器人操作系统入门 Tutorials CN版 20150726

    提供类似于操作系统的服务，包括硬件抽象描述、底层驱动程序管理、共用功能的执行、程序间消息传递、程序发行包管理，它也提供一些工具和库用于获取、建立、编写和执行多机融合的程序。 ROS的运行架构是一种使用ROS...

Magicbox
Global site tag (gtag.js) - Google Analytics