`

Java Message Service 点对点编程

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

文章来源（IBM中国）

1、介绍

在这一节中，我们将分析两个进行点对点消息接发的程序—— QSender.java 和 QReceiver.java。

我们将在一些小节中分析代码并描述每一小节的功能。

2、QSender:提示输入 JNDI 名称~

这两个示例程序都是命令行程序， 用 System.in 输入、用 System.out 输出。 QSender 类有两个方法：main(String[]) 和 send()。main(String[]) 方法只举例说明了 QSender ，并调用了它的 send() 方法。send() 方法的第一部分提示输入用来发送消息受管理对象的 JNDI 的名称。

  1. import java.io.*;   
  2. import javax.jms.*;   
  3. import javax.naming.*;   
  4.   
  5. public class QSender {   
  6.   
  7.     public static void main(String[] args) {   
  8.   
  9.         new QSender().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 QueueConnectionFactory name:");   
  19.             String factoryName = reader.readLine();   
  20.             System.out.println("Enter Queue name:");   
  21.             String queueName = reader.readLine();   
  22.     . . .  

3、QSender查找管理对象 

send() 方法的第二部分用前面输入的名字在 JNDI 中查找受管理的对象。通过举例说明 InitialContext 对象访问 JNDI，通过调用lookup(String) 方法并传递要获取的对象的名字来检索受管理的对象。注意， lookup(String) 方法返回的是 Object，所以必须对返回的对象进行类型强制转换。


 

  1. . . .   
  2.         //Look up administered objects   
  3.         InitialContext initContext = new InitialContext();   
  4.         QueueConnectionFactory factory =   
  5.             (QueueConnectionFactory) initContext.lookup(factoryName);   
  6.         Queue queue = (Queue) initContext.lookup(queueName);   
  7.         initContext.close();   
  8.         . . .   

4、QSender：创建 JMS 对象

现在，我们已创建了发送消息所需要的 JMS 对象。注意，我们没有用 new 直接举例说明这些对象。所有对象都是通过调用另一个对象的方法创建的。
首先，用 QueueConnectionFactory 创建 QueueConnection。然后用 QueueConnection 创建一个 QueueSession。
QueueSession 不是经过处理的（false），并且它将使用自动确认 （Session.AUTO_ACKNOWLEDGE）。
最后，创建 QueueSender 将信息发送到从 JNDI 中检索的 Queue 发送消息。

  1. . . .   
  2.         //Create JMS objects   
  3.         QueueConnection connection = factory.createQueueConnection();   
  4.         QueueSession session =   
  5.             connection.createQueueSession(false, Session.AUTO_ACKNOWLEDGE);   
  6.         QueueSender sender = session.createSender(queue);   
  7.         . . .  

5、QSender：发送消息

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

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

  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.         . . .   

 6、QSender：退出

退出循环后，关闭 QueueConnection。关闭 QueueConnection 会自动关闭 QueueSession 和 QueueSender。

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. }   

7、QReceiver提示输入 JNDI 名称并查找受管理的对象

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

提示输入 JNDI 名字并查找受管理对象的代码与 QSender 中的代码完全一样。
不过，在这个类中有两处不一样的地方：
boolean stop 实例变量被用来指出程序应该退出。
QReceiver 可以实现 MessageListener 接口来异步接收消息。

  1. import java.io.*;   
  2. import javax.jms.*;   
  3. import javax.naming.*;   
  4.   
  5. public class QReceiver implements MessageListener {   
  6.   
  7.     private boolean stop = false;   
  8.   
  9.     public static void main(String[] args) {   
  10.   
  11.         new QReceiver().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 QueueConnectionFactory name:");   
  21.             String factoryName = reader.readLine();   
  22.             System.out.println("Enter Queue name:");   
  23.             String queueName = reader.readLine();   
  24.             reader.close();   
  25.   
  26.             //Look up administered objects   
  27.             InitialContext initContext = new InitialContext();   
  28.             QueueConnectionFactory factory =   
  29.                 (QueueConnectionFactory) initContext.lookup(factoryName);   
  30.             Queue queue = (Queue) initContext.lookup(queueName);   
  31.             initContext.close();   
  32.             . . .  

 

8、QReceiver：创建 JMS 对象

像在 QSender 中那样创建 QueueConnection 和 QueueSession，然后创建一个 QueueReceiver。

接着，调用 setMessageListener()，传递 QReceiver 的本地实例 this，我们将重调它来实现 MessageListener 接口。

最后，启动 QueueConnection 来接收消息。

  1. . . .   
  2.         //Create JMS objects   
  3.         QueueConnection connection = factory.createQueueConnection();   
  4.         QueueSession session =   
  5.             connection.createQueueSession(false, Session.AUTO_ACKNOWLEDGE);   
  6.         QueueReceiver receiver = session.createReceiver(queue);   
  7.         receiver.setMessageListener(this);   
  8.         connection.start();   
  9.         . . .   

9、QReceiver：等待 stop 并退出

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

  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. . . .  

10、QReceiver：onMessage(Message) 方法

需要包含 QReceiver 类的 onMessage(Message) 方法，因为 QReceiver 可以实现 MessageListener 接口。

接收消息时，就调用这个方法，并将 Message 作为参数传递。

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

 

  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. }   


11、源码QSender.java 的代码清单

java 代码
  1. import java.io.*;   
  2. import javax.jms.*;   
  3. import javax.naming.*;   
  4.   
  5. public class QSender {   
  6.   
  7.     public static void main(String[] args) {   
  8.   
  9.         new QSender().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 QueueConnectionFactory name:");   
  19.             String factoryName = reader.readLine();   
  20.             System.out.println("Enter Queue name:");   
  21.             String queueName = reader.readLine();   
  22.   
  23.             //Look up administered objects   
  24.             InitialContext initContext = new InitialContext();   
  25.             QueueConnectionFactory factory =   
  26.                 (QueueConnectionFactory) initContext.lookup(factoryName);   
  27.             Queue queue = (Queue) initContext.lookup(queueName);   
  28.             initContext.close();   
  29.   
  30.             //Create JMS objects   
  31.             QueueConnection connection = factory.createQueueConnection();   
  32.             QueueSession session =   
  33.                 connection.createQueueSession(false, Session.AUTO_ACKNOWLEDGE);   
  34.             QueueSender sender = session.createSender(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. }   

 

12、源码QReceiver .java 的代码清单

java 代码
  1. import java.io.*;   
  2. import javax.jms.*;   
  3. import javax.naming.*;   
  4.   
  5. public class QReceiver implements MessageListener {   
  6.   
  7.     private boolean stop = false;   
  8.   
  9.     public static void main(String[] args) {   
  10.   
  11.         new QReceiver().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 QueueConnectionFactory name:");   
  21.             String factoryName = reader.readLine();   
  22.             System.out.println("Enter Queue name:");   
  23.             String queueName = reader.readLine();   
  24.             reader.close();   
  25.   
  26.             //Look up administered objects   
  27.             InitialContext initContext = new InitialContext();   
  28.             QueueConnectionFactory factory =   
  29.                 (QueueConnectionFactory) initContext.lookup(factoryName);   
  30.             Queue queue = (Queue) initContext.lookup(queueName);   
  31.             initContext.close();   
  32.   
  33.             //Create JMS objects   
  34.             QueueConnection connection = factory.createQueueConnection();   
  35.             QueueSession session =   
  36.                 connection.createQueueSession(false, Session.AUTO_ACKNOWLEDGE);   
  37.             QueueReceiver receiver = session.createReceiver(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. }   


分享到：
| Java Message Service 点对点接口
评论
发表评论

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

相关推荐

    java message service 第二版

    - **点对点API**：用于实现点对点消息传递模式的具体API。 - **发布/订阅API**：用于实现发布/订阅消息传递模式的具体API。 #### 深入理解 - **异构集成**：JMS支持不同系统间的通信，无论这些系统是基于哪种...

    Introducing the Java Message Service

    点对点编程模型适用于那些需要确切一次处理的应用场景，如订单处理或事务处理。 ### 发布/订阅接口与编程 与点对点模型不同，发布/订阅模型允许消息被多个订阅者接收。在这一模型中，消息生产者并不直接将消息发送...

    Java Message Service

    JMS是Java平台中的一个关键组成部分，主要用于实现异步通信，并且支持消息的传递机制，如点对点(PTP)和发布/订阅(Pub/Sub)模式。 #### 二、JMS的优势 **1. 异构系统集成** JMS支持不同平台和编程语言之间的消息...

    Java实现的点对点短消息发送协议(smpp)开发包源码.rar

    点对点短消息发送协议（SMPP）是一种用于在服务提供商和短消息实体之间传输SMS（Short Message Service）数据的应用层协议。Java实现的SMPP开发包源码为我们提供了理解和构建基于Java的短信发送系统的基础。这个开发...

    [JAVA编程模式与范例].zip

    - JMS（Java Message Service）中，观察者模式用于消息发布/订阅模型。 3. **Java编程范例**： - 多线程编程：通过Thread类或Runnable接口创建线程，理解同步机制如synchronized关键字、wait/notify机制。 - ...

    java 网络高级编程(PDF)201242

    它支持点对点（队列）和发布/订阅（主题）两种模式，实现异步解耦和可靠的消息传输。 4. **Java Mail技术**：Java Mail API提供了在Java应用中发送和接收电子邮件的功能。它可以处理SMTP、POP3和IMAP协议，允许...

    Java网络高级编程

    第8章介绍了异步消息服务技术JMS（Java Message Service）和Java Mail技术，JMS允许应用程序之间通过消息传递进行通信，而Java Mail则是用于电子邮件处理的API。第9章则聚焦于利用WebLogic服务器的EJB（Enterprise ...

    java EE编程技术

    Java Message Service (JMS) 是Java平台中用于创建、发送、接收和读取消息的标准API。在Java EE中，JMS常用于实现异步通信，提高系统的响应速度和可扩展性。消息队列是JMS的一种实现，可以缓冲和转发消息，使得不同...

    基于smpp协议的Java点对点短信发送源码包.zip

    这个“基于SMPP协议的Java点对点短信发送源码包”提供了使用Java编程语言实现SMPP协议的具体示例，帮助开发者构建自己的短信服务系统。 SMPP协议是电信行业中用来处理SMS（Short Message Service）的开放标准，它...

    Java服务器高级编程

    6. **JMS（Java Message Service）**：Java消息服务允许应用程序之间进行异步通信。书中会介绍JMS的基本概念，如消息队列和主题，以及如何在Java EE应用中使用JMS进行解耦和异步处理。 7. **JPA（Java Persistence ...

    Java实现的点对点短消息发送协议(smpp)开发包源码

    Java实现的点对点短消息发送协议（SMPP）是一种基于TCP/IP协议栈的应用层协议，主要用于电信行业的短信服务。SMPP（Short Message Peer-to-Peer）为移动运营商和第三方应用提供了一种标准接口，使得应用程序能够直接...

    网页Java编程，很不错

    5. **Java EE（Enterprise Edition）**：Java EE是Java平台的企业版，提供了一系列API和服务，如JSP、Servlet、EJB（Enterprise JavaBeans）、JMS（Java Message Service）等，用于开发分布式企业级应用。...

    Java 服务器高级编程

    以上只是Java服务器高级编程的一些主要知识点，实际的学习和实践中，还需要对服务器环境配置、日志管理、性能监控、异常处理、故障排查等多个方面有深入的理解和实践经验。"www_sj00_com.txt"和"javaserverprogram02...

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