JMS入门


1 基本信息

摘要:本篇为JMS的学习笔记, 教你一步一步使用JMS,并提供一个能运行的完整的案例,可以使人达到快速入门的目的。

2 正文

  JMS(Java Message Service),是Java消息服务,通过JMS,可以在Java对象之间发送消息。JMS消息支持点对点之间的消息发送,也支持主题/订阅方式的消息发送。

  /** 注: 本笔记中的代码针在jboss4.0.5下运行通过 */

  消息服务由客户和消息代理组成。每位客户都连接到消息服务,客户可以创建消息、发送消息、接收消息、阅读消息。消息服务可以将接收到的消息转发给其他的客户。

  消息服务的关键特点:客户只需要最少的信息就可以其他客户通信(需知道其他客户的提供的服务、服务所需信息和客户地址)。

  消息服务使用转发-存储结构以提交异步信息。

  JMS包含5个元素:

•  提供者: 负责管理消息服务的消息代理
•  客户:   java编写的,利用提供者进行通信的应用程序和组件
•  消息:   在客户之间传输的对象
•  管理的对象: 传输中使用的jms对象,分两种,目标工厂(Destination Factory)对象和连接对象,用于连接消息服务,处理发送者和接收者之间的传输。
•  本机客户: 是在引入jms之前构建的应用程序,它们是采用另外一种消息系统的本机客户API

  在引入jms之前,客户是用 点对点 和 订阅/发布结构

  jms的5个元素:

•  管理对象: 连接工厂(Connection Factory)对象和会话对象;连接工厂对象用于创建会话对象;会话对象用于创建发送者和接收者
    ConnectionFactory(QueueConnectionFactory,TopicConnectionFactoy,XAQueueConnectionFactory,XATopicConnectionFactoy)
    Connection(QueueConnection,TopicConnection,XAQueueConnection,XATopicConnection)
•  会话:   Session
•  消息生成者: MessageProducer(QueueSender, TopicPublisher)
•  消息使用者: MessageConsumer(QueueReciever,TopicSubscriber)
•  消息:   Message

  jms使用步骤:

1 访问连接工厂:

  1. InitialContext ctx=new InitialContext();
  2. TopicConnectionFactory tcf=(TopicConnectionFactory) ctx.lookup("TopicConnectionFactory");
  3. QueueConnectionFactory qcf=(QueueConnectionFactory) ctx.lookup("QueueConnectionFactory");

2 访问目标工厂:创建Queue对象/Topic对象

  1. Topic mt=(Topic) ctx.lookup("topic/testTopic");
  2. Queue mq=(Queue) ctx.lookup("queue/A");

3 创建连接,分两种:队列连接和主题连接

  1. TopicConnection tc=tcf.createTopicConnection();
  2. QueueConnection qc=qcf.createQueueConnection();

4. 开始接收:也可以放在后面进行

  1. tc.start(); //以后需要调用 tc.close(); 关闭连接
  2. qc.start(); //以后需要调用 qc.close(); 关闭连接

5. 创建会话:会话用于创建消息生产者、消息消费者、消息。

  1. QueueSession qSession=qc.createQueueSession(true,0);
  2. TopicSession tSession=tc.createTopicSession(false,Session.AUTO_ACKNOWLEDGE);

参数1:是否使用事务
参数2:消息确认模式

  当消息发送者向消息提供者(即消息代理)发送消息时,消息发送者等待消息代理的确认,没有回应则抛出异常,消息发送程序负责处理这个错误。

  注:消息代理确认只是确认收到了消息,而不是确认消息提交给了消息接收者。

  消息确认模式:JMS使用确认协议以保证消息的发送,使用了3种确认模式

AUTO_ACKNOWLEDGE : 指定消息提供者在每次收到消息时自动发送确认。消息只向目标发送一次,但传输过程中可能因为错误而丢失消息。
CLIENT_ACKNOWLEDGE : 由消息接收者确认收到消息,通过调用消息的acknowledge()方法(会通知消息提供者收到了消息)
DUPS_OK_ACKNOWLEDGE : 指定消息提供者在消息接收者没有确认发送时重新发送消息(这种确认模式不在乎接收者收到重复的消息)。如

   消息提供者在试图向非持久化的消息接收者发送消息失败时,消息会丢失。在向持久化消息接收者发送消息时,会等待消息接收者确认,未收到确认,则重新发送 消息(消息提供者需要设置JMSRedilivered=true,消息接收者需要调用Message对象的getJMSRedelivered()方法 确认JMSRedilivered标记是否为true)

CLIENT_ACKNOWLEDGE 确认收到消息代码:

  1. public void onMessage(Message msg){
  2. try{
  3. //Process incoming messages
  4. msg.acknowledge();
  5. }catch(Exception e){
  6. //handle error
  7. }
  8. }

  消息事务: 包含一组消息,要么全部发送,要不全部都不发送给消息提供者。

  消息提供者缓存消息,如果消息发送者有一个消息发送失败,则调用session.rollback()方法,则消息提供者会放弃前面发送成功的消息;如果全部发送成功,调用session.commit()方法,将消息全部发送给消息接收者。

6 创建消息生产者:

  1. QueueSender qSender=qSession.createSender(mq);
  2. TopicPublisher tPublisher=tSession.createPublisher(mt);
  3. qSender.send(msg);
  4. tPublisher.publish(msg);

7 创建消息使用者:在接收任何消息之前,客户必须注册到JMS提供者表明希望接收消息。注册后,JMS提供者就负责向客户发送消息。

  1. QueueReceiver qr=qSession.createReceiver(mq);
  2. qc.start();
  3. Message msg1=qr.receive();
  4. TopicSubscriber tSubscriber=tSession.createSubscriber(mt);
  5. tc.start();
  6. Message msg2=tSubscriber.receive(1500); //每隔1500毫秒从主题接收一次

8 创建消息监听器(实现MessageListener接口onMessage()方法):消息使用者通过消息监听器异步接收消息。

  1. QueueListener qListener=new QueueListener(); //QueueListener为自定义类,实现MessageListener接口
  2. qr.setMessageListener(qListener);
  3. TopicListener tListener=new TopicListener(); //TopicListener为自定义类,实现MessageListener接口
  4. tSubscriber.setMessageListener(tListener);

9 消息(Message):三部分,头(必须的),属性和正文 (二者为可选)。

  消息头读写方法: getXXX(),setXXX()

  XXX是字段的名字,许多消息字段是由send()和publish()方法自动设置的,其他自动则由客户或者JMS程序设置。

1) 由send() or publish()设置的:

  1. JMSDestination
  2. JMSDeliveryMode
  3. JMSExpiration
  4. JMSPriority
  5. JMSMessageID
  6. JMSTimestamp
  7. JMSCorrelationID: 关联消息ID
  8. JMSReplyTo
  9. JMSType
  10. JMSRedelivered

2)由客户设置的:

  1. JMSCorrelationID: 关联消息ID
  2. JMSReplyTo
  3. JMSType

3) 由jms提供者设置的:

  1. JMSRedelivered

## 属性读写方法:   getXXX(name), setXXX(name,value)

  消息正文:包含消息,JMS支持6种消息格式,称为消息类型

TextMessage:   有文本组成的String对象
MapMessage:   可以是按顺序或随机访问的 key-value对,key为String, value为primitive
BytesMessage: 字节信息(如存放图像)
StreamMessage: 包含顺序读取值的流
ObjectMessage: 可以序列化的java对象
Message:   无消息正文时可以使用

创建TextMessage消息:

  1. TextMessage msg=qSession.createTextMessage();
  2. msg.setText("myMessage");
  3. qSender.send(msg);

读取TextMessage消息:

  1. Message msg=qr.receive();
  2. if(msg instanceof TextMessage){
  3. TextMessage txtMsg=(TextMessage) msg;
  4. System.out.println("Imcoming message: "+txtMsg.getText());
  5. }else{
  6. //handle error
  7. }

10. 消息选择器:消息使用者使用消息选择器(message selector)选择收到的消息。消息选择器使用条件表达式(符合WHERE子句的SQL-92标准)作为选择条件。
创建并使用消息选择器:

  1. String criteria="Customer='1234'";
  2. TopicSubscriber tSubscriber=ts.createSubscriber(myTopic,criteria,false); //只从主题中接收Customer='1234'的消息

### 向队列发送消息

  1. SendToQueue.java:
  2. package test.jms;
  3. import java.util.Properties;
  4. import javax.jms.*;
  5. import javax.naming.*;
  6. public class SendToQueue {
  7. public static void main(String[] args) {
  8. final int msgCount;
  9. if( (args.length<1) || ( args.length>2)) {
  10. System.out.println("Usage: java test.jms.SendToQueue queueName [sendCount]");
  11. System.exit(1);
  12. }
  13. String qName=new String(args[0]);
  14. if(args.length==2) {
  15. msgCount=(new Integer(args[1]).intValue());
  16. }else {
  17. msgCount=1;
  18. }
  19. QueueConnection qc=null;
  20. try {
  21. Properties p = new Properties();
  22. p.setProperty(Context.INITIAL_CONTEXT_FACTORY,
  23. "org.jnp.interfaces.NamingContextFactory");
  24. p.setProperty(Context.PROVIDER_URL, "localhost:1099");
  25. InitialContext jc=new InitialContext(p);
  26. QueueConnectionFactory qcf=(QueueConnectionFactory)jc.lookup("QueueConnectionFactory");
  27. Queue q=(Queue)jc.lookup(qName);
  28. qc=qcf.createQueueConnection();
  29. QueueSession qs=qc.createQueueSession(false, Session.AUTO_ACKNOWLEDGE);
  30. QueueSender qSender=qs.createSender(q);
  31. TextMessage msg=qs.createTextMessage();
  32. for(int i=0;i<msgCount;i++) {
  33. msg.setText("Welcome number "+(i+1));
  34. qSender.send(msg);
  35. System.out.println("Send Message To "+qName+" : "+msg.getText()+"\n");
  36. }
  37. qSender.close();
  38. qs.close();
  39. }catch(Exception e) {
  40. e.printStackTrace();
  41. }finally {
  42. if(qc!=null) {
  43. try {
  44. qc.close();
  45. }catch(JMSException e) {}
  46. }
  47. }
  48. }
  49. }

运行: java test.jms.SendToQueue queue/A 10

### 从队列接收消息

  1. ReceiveFromQueue.java:
  2. package test.jms;
  3. import java.io.*;
  4. import java.util.Properties;
  5. import javax.jms.*;
  6. import javax.naming.*;
  7. public class ReceiveFromQueue {
  8. public static void doReceive(String qName) {
  9. Message msg;
  10. TextMessage txtMsg;
  11. QueueConnection qc = null;
  12. try {
  13. Properties p = new Properties();
  14. p.setProperty(Context.INITIAL_CONTEXT_FACTORY,
  15. "org.jnp.interfaces.NamingContextFactory");
  16. p.setProperty(Context.PROVIDER_URL, "localhost:1099");
  17. InitialContext jc = new InitialContext(p);
  18. QueueConnectionFactory qcf = (QueueConnectionFactory) jc
  19. .lookup("QueueConnectionFactory");
  20. Queue q = (Queue) jc.lookup(qName);
  21. qc = qcf.createQueueConnection();
  22. QueueSession qs = qc.createQueueSession(false,
  23. Session.AUTO_ACKNOWLEDGE);
  24. QueueReceiver qr = qs.createReceiver(q);
  25. qc.start();
  26. System.out.println("begin receive messge from " + qName + "...");
  27. msg = qr.receive(1000); // 如果不加间隔参数,会一直等着,知道消息到来。
  28. while (msg != null) {
  29. if (msg instanceof TextMessage) {
  30. txtMsg = (TextMessage) msg;
  31. System.out.println("Receive Msg from " + qName + " : "
  32. + txtMsg.getText());
  33. }
  34. msg = qr.receive(1000);
  35. }
  36. System.out.println("no message available!");
  37. qr.close();
  38. qs.close();
  39. } catch (Exception e) {
  40. e.printStackTrace();
  41. } finally {
  42. if (qc != null) {
  43. try {
  44. qc.close();
  45. } catch (JMSException e) {
  46. }
  47. }
  48. }
  49. }
  50. public static void doListen(String qName) {
  51. Message msg;
  52. TextMessage txtMsg;
  53. QueueConnection qc = null;
  54. try {
  55. Properties p = new Properties();
  56. p.setProperty(Context.INITIAL_CONTEXT_FACTORY,
  57. "org.jnp.interfaces.NamingContextFactory");
  58. p.setProperty(Context.PROVIDER_URL, "localhost:1099");
  59. InitialContext jc = new InitialContext(p);
  60. QueueConnectionFactory qcf = (QueueConnectionFactory) jc
  61. .lookup("QueueConnectionFactory");
  62. Queue q = (Queue) jc.lookup(qName);
  63. qc = qcf.createQueueConnection();
  64. QueueSession qs = qc.createQueueSession(false,
  65. Session.AUTO_ACKNOWLEDGE);
  66. QueueReceiver qr = qs.createReceiver(q);
  67. qc.start();
  68. System.out.println("begin listen to messge from " + qName + "...");
  69. TextListener tListener = new TextListener();
  70. qr.setMessageListener(tListener);
  71. qc.start();
  72. System.out.println("Enter 'q' and press <return> to exit ");
  73. InputStreamReader isr = new InputStreamReader(System.in);
  74. char response = '\0';
  75. while (!((response == 'q') || (response == 'Q'))) {
  76. try {
  77. response = (char) isr.read();
  78. } catch (IOException e) {
  79. e.printStackTrace();
  80. }
  81. }
  82. System.out.println("End listening!");
  83. qr.close();
  84. qs.close();
  85. } catch (Exception e) {
  86. e.printStackTrace();
  87. } finally {
  88. if (qc != null) {
  89. try {
  90. qc.close();
  91. } catch (JMSException e) {
  92. }
  93. }
  94. }
  95. }
  96. public static void main(String[] args) {
  97. if ((args.length != 1)) {
  98. System.out
  99. .println("Usage: java test.jms.ReceiveFromQueue queueName");
  100. System.exit(1);
  101. }
  102. String qName = new String(args[0]);
  103. doReceive(qName); //通过QueueReceiver.receive()读消息
  104. doListen(qName); // 通过消息监听器读消息
  105. }
  106. }

原文地址:http://wenku.baidu.com/view/2eccd9a10029bd64783e2c24.html
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值