`
isiqi
  • 浏览: 16497914 次
  • 性别: Icon_minigender_1
  • 来自: 济南
社区版块
存档分类
最新评论

JMS入门,好东西

JMSJBoss应用服务器SQL 
阅读更多

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();
  5. TopicSubscriber tSubscriber=tSession.createSubscriber(mt);
  6. tc.start();
  7. Message msg2=tSubscriber.receive(1500); //每隔1500毫秒从主题接收一次

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

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

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

### 从队列接收消息

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

运行： java test.jms.ReceiveFromQueue queue/A

### 向主题发送消息

  1. PublishToTopic.java:
  2. package test.jms;
  4. import java.util.Properties;
  6. import javax.jms.*;
  7. import javax.naming.*;
  9. public class PublishToTopic {
  10. public static void main(String[] args) {
  11. final int msgCount;
  12. if( (args.length<1) || ( args.length>2)) {
  13. System.out.println("Usage: java test.jms.PublishToTopic topicName [sendCount]");
  14. System.exit(1);
  15. }
  17. String tName=new String(args[0]);
  18. if(args.length==2) {
  19. msgCount=(new Integer(args[1]).intValue());
  20. }else {
  21. msgCount=10;
  22. }
  24. TopicConnection tc=null;
  25. try {
  26. Properties p = new Properties();
  27. p.setProperty(Context.INITIAL_CONTEXT_FACTORY,
  28. "org.jnp.interfaces.NamingContextFactory");
  29. p.setProperty(Context.PROVIDER_URL, "localhost:1099");
  31. InitialContext jc=new InitialContext(p);
  32. TopicConnectionFactory tcf=(TopicConnectionFactory)jc.lookup("TopicConnectionFactory");
  33. Topic t=(Topic)jc.lookup(tName);
  34. tc=tcf.createTopicConnection();
  35. TopicSession ts=tc.createTopicSession(false, Session.AUTO_ACKNOWLEDGE);
  36. TopicPublisher tp=ts.createPublisher(t);
  37. TextMessage msg=ts.createTextMessage();
  38. for(int i=0;i<msgCount;i++) {
  39. msg.setText("Welcome number "+(i+1));
  40. tp.publish(msg);
  41. System.out.println("Publish Message To "+tName+" : "+msg.getText()+"\n");
  42. }
  43. tp.close();
  44. ts.close();
  45. }catch(Exception e) {
  46. e.printStackTrace();
  47. }finally {
  48. if(tc!=null) {
  49. try {
  50. tc.close();
  51. }catch(JMSException e) {}
  52. }
  53. }
  54. }
  55. }

运 行： java -classpath d:\jboss-4.0.5\client\jnp-client.jar;d:\jboss-4.0.5\client\jbossmq-client.jar;d:\jboss-4.0.5\client\jboss-j2ee.jar;d:\jboss-4.0.5\client\jbossall-client.jar;. test.jms.PublishToTopic topic/testTopic

### 从主题接收消息

  1. SubscribeFromTopic.java:
  2. package test.jms;
  4. import java.io.IOException;
  5. import java.io.InputStreamReader;
  6. import java.util.Properties;
  8. import javax.jms.*;
  9. import javax.naming.*;
  11. public class SubscribeFromTopic {
  12. public static void doListen(String tName) {
  13. char response='\0';
  15. TopicConnection tc=null;
  16. try {
  17. Properties p = new Properties();
  18. p.setProperty(Context.INITIAL_CONTEXT_FACTORY,
  19. "org.jnp.interfaces.NamingContextFactory");
  20. p.setProperty(Context.PROVIDER_URL, "localhost:1099");
  22. InitialContext jc=new InitialContext(p);
  23. TopicConnectionFactory tcf=(TopicConnectionFactory)jc.lookup("TopicConnectionFactory");
  24. Topic t=(Topic)jc.lookup(tName);
  25. tc=tcf.createTopicConnection();
  26. TopicSession ts=tc.createTopicSession(false, Session.AUTO_ACKNOWLEDGE);
  27. TopicSubscriber tSubscriber=ts.createSubscriber(t);
  29. System.out.println("begin listen to messge from "+tName+"...");
  30. TextListener tListener=new TextListener();
  31. tSubscriber.setMessageListener(tListener);
  32. tc.start();
  33. System.out.println("Enter 'q' and press <return> to exit ");
  34. InputStreamReader isr=new InputStreamReader(System.in);
  35. while(!( (response=='q') || (response=='Q' ))) {
  36. try {
  37. response=(char)isr.read();
  38. }catch(IOException e) {
  39. e.printStackTrace();
  40. }
  41. }
  42. System.out.println("End listening!");
  44. tSubscriber.close();
  45. ts.close();
  46. }catch(Exception e) {
  47. e.printStackTrace();
  48. }finally {
  49. if(tc!=null) {
  50. try {
  51. tc.close();
  52. }catch(JMSException e) {}
  53. }
  54. }
  55. }
  57. public static void doSubscribe(String tName) {
  58. Message msg;
  59. TextMessage txtMsg;
  60. TopicConnection tc=null;
  61. try {
  62. Properties p = new Properties();
  63. p.setProperty(Context.INITIAL_CONTEXT_FACTORY,
  64. "org.jnp.interfaces.NamingContextFactory");
  65. p.setProperty(Context.PROVIDER_URL, "localhost:1099");
  67. InitialContext jc=new InitialContext(p);
  68. TopicConnectionFactory tcf=(TopicConnectionFactory)jc.lookup("TopicConnectionFactory");
  69. Topic t=(Topic)jc.lookup(tName);
  70. tc=tcf.createTopicConnection();
  71. TopicSession ts=tc.createTopicSession(false, Session.AUTO_ACKNOWLEDGE);
  72. TopicSubscriber tSubscriber=ts.createSubscriber(t);
  74. System.out.println("begin listen to messge from "+tName+"...");
  76. System.out.println("begin receive messge from " + tName + "...");
  77. msg = tSubscriber.receive(1000);
  78. while (msg != null) {
  79. if (msg instanceof TextMessage) {
  80. txtMsg = (TextMessage) msg;
  81. System.out.println("Receive Msg from " + tName + " : "
  82. + txtMsg.getText());
  83. }
  84. msg = tSubscriber.receive(1000);
  85. }
  86. System.out.println("no message available!");
  88. tSubscriber.close();
  89. ts.close();
  90. }catch(Exception e) {
  91. e.printStackTrace();
  92. }finally {
  93. if(tc!=null) {
  94. try {
  95. tc.close();
  96. }catch(JMSException e) {}
  97. }
  98. }
  99. }
  101. public static void main(String[] args) {
  102. if( (args.length!=1)) {
  103. System.out.println("Usage: java test.jms.SubscribeFromTopic topicName");
  104. System.exit(1);
  105. }
  107. String tName=new String(args[0]);
  108. doListen(tName); //通过消息监听器接收消息
  109. // doSubscribe(tName); //通过receive()来接收消息
  110. }
  111. }

运 行： java -classpath d:\jboss-4.0.5\client\jnp-client.jar;d:\jboss-4.0.5\client\jbossmq-client.jar;d:\jboss-4.0.5\client\jboss-j2ee.jar;d:\jboss-4.0.5\client\jbossall-client.jar;. test.jms.SubscribeFromTopic topic/testTopic

附：TextListener.java:

  1. SubscribeFromTopic.java:
  2. package test.jms;
  4. import java.io.IOException;
  5. import java.io.InputStreamReader;
  6. import java.util.Properties;
  8. import javax.jms.*;
  9. import javax.naming.*;
  11. public class SubscribeFromTopic {
  12. public static void doListen(String tName) {
  13. char response='\0';
  15. TopicConnection tc=null;
  16. try {
  17. Properties p = new Properties();
  18. p.setProperty(Context.INITIAL_CONTEXT_FACTORY,
  19. "org.jnp.interfaces.NamingContextFactory");
  20. p.setProperty(Context.PROVIDER_URL, "localhost:1099");
  22. InitialContext jc=new InitialContext(p);
  23. TopicConnectionFactory tcf=(TopicConnectionFactory)jc.lookup("TopicConnectionFactory");
  24. Topic t=(Topic)jc.lookup(tName);
  25. tc=tcf.createTopicConnection();
  26. TopicSession ts=tc.createTopicSession(false, Session.AUTO_ACKNOWLEDGE);
  27. TopicSubscriber tSubscriber=ts.createSubscriber(t);
  29. System.out.println("begin listen to messge from "+tName+"...");
  30. TextListener tListener=new TextListener();
  31. tSubscriber.setMessageListener(tListener);
  32. tc.start();
  33. System.out.println("Enter 'q' and press <return> to exit ");
  34. InputStreamReader isr=new InputStreamReader(System.in);
  35. while(!( (response=='q') || (response=='Q' ))) {
  36. try {
  37. response=(char)isr.read();
  38. }catch(IOException e) {
  39. e.printStackTrace();
  40. }
  41. }
  42. System.out.println("End listening!");
  44. tSubscriber.close();
  45. ts.close();
  46. }catch(Exception e) {
  47. e.printStackTrace();
  48. }finally {
  49. if(tc!=null) {
  50. try {
  51. tc.close();
  52. }catch(JMSException e) {}
  53. }
  54. }
  55. }
  57. public static void doSubscribe(String tName) {
  58. Message msg;
  59. TextMessage txtMsg;
  60. TopicConnection tc=null;
  61. try {
  62. Properties p = new Properties();
  63. p.setProperty(Context.INITIAL_CONTEXT_FACTORY,
  64. "org.jnp.interfaces.NamingContextFactory");
  65. p.setProperty(Context.PROVIDER_URL, "localhost:1099");
  67. InitialContext jc=new InitialContext(p);
  68. TopicConnectionFactory tcf=(TopicConnectionFactory)jc.lookup("TopicConnectionFactory");
  69. Topic t=(Topic)jc.lookup(tName);
  70. tc=tcf.createTopicConnection();
  71. TopicSession ts=tc.createTopicSession(false, Session.AUTO_ACKNOWLEDGE);
  72. TopicSubscriber tSubscriber=ts.createSubscriber(t);
  74. System.out.println("begin listen to messge from "+tName+"...");
  76. System.out.println("begin receive messge from " + tName + "...");
  77. msg = tSubscriber.receive(1000);
  78. while (msg != null) {
  79. if (msg instanceof TextMessage) {
  80. txtMsg = (TextMessage) msg;
  81. System.out.println("Receive Msg from " + tName + " : "
  82. + txtMsg.getText());
  83. }
  84. msg = tSubscriber.receive(1000);
  85. }
  86. System.out.println("no message available!");
  88. tSubscriber.close();
  89. ts.close();
  90. }catch(Exception e) {
  91. e.printStackTrace();
  92. }finally {
  93. if(tc!=null) {
  94. try {
  95. tc.close();
  96. }catch(JMSException e) {}
  97. }
  98. }
  99. }
  101. public static void main(String[] args) {
  102. if( (args.length!=1)) {
  103. System.out.println("Usage: java test.jms.SubscribeFromTopic topicName");
  104. System.exit(1);
  105. }
  107. String tName=new String(args[0]);
  108. doListen(tName); //通过消息监听器接收消息
  109. // doSubscribe(tName); //通过receive()来接收消息
  110. }
  111. }
分享到：
| 周杰伦新女友现身
评论
发表评论

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

相关推荐

    JMS入门文档，JMS入门文档

    通过阅读JMS入门文档，你可以了解如何配置和使用JMS API来实现这些功能，并理解其在实际项目中的应用方式。对于初学者来说，这些文档会提供一个良好的起点，帮助他们逐步掌握JMS的核心概念和实践技巧，从而在开发中...

    jms 入门的几个小项目

    JMS（Java Message Service）是Java平台中用于创建和管理消息传递系统的一种API，它提供了一种标准的方式来...在实践中，你可能会遇到各种挑战，但随着经验的增长，你会更好地了解如何利用JMS优化系统的性能和稳定性。

    jms入门实例

    Java消息服务（Java Message Service，简称...例如，Test文件可能包含了JMS的入门示例代码，展示了如何创建消息、设置消息代理、发送和接收消息的过程。通过学习和实践这些示例，开发者能更好地理解和掌握JMS的使用。

    spring-jms入门

    Spring-JMS是Spring框架的一部分，专门用于处理Java消息服务（JMS）的集成。它提供了一个简单的API，使得开发者能够方便地在应用中使用消息传递功能。本文将深入探讨Spring-JMS的基础知识，包括它的核心概念、配置...

    JMS入门小例子以及weblogic安装，并且在weblogic中配置JMS服务

    总的来说，JMS入门实例结合WebLogic的安装和配置，为初学者提供了一个了解和实践Java消息服务的完整流程。通过这个过程，开发者可以学习到如何在WebLogic这样的企业级应用服务器上构建可靠的消息传递系统，以及如何...

    JMS-ActiveMQ入门实例

    **JMS与ActiveMQ入门实例详解** Java消息服务（Java Message Service，简称JMS）是Java平台中用于创建、发送、接收和阅读消息的应用程序接口。它为应用程序提供了标准的接口，可以跨越多种消息中间件产品进行通信。...

    JMS入门

    【JMS入门】这篇文章主要介绍了Java消息服务（Java Message Service，简称JMS）的基本概念和如何使用开源的JMS服务器OpenJMS进行实践操作。JMS是一种标准接口，用于应用程序之间的异步通信，特别是在分布式环境中，...

    JMS入门Demo

    该属性值默认为false，这样JMS在进行消息监听的时候就会进行事务控制，当在接收消息时监听器执行失败时JMS就会对接收到的消息进行回滚， 对于SessionAwareMessageListener在接收到消息后发送一个返回消息时也处于...

    WebLogic_server8.1_JMS入门.doc

    【WebLogic Server 8.1 JMS 入门】 WebLogic Server 8.1 是一款符合J2EE 1.3规范的中间件，其中包含了WebLogic JMS Server，它是基于Java Message Service (JMS) 的实现，允许Java应用程序进行可靠的消息交换。JMS...

    jms入门

    **JMS（Java Message Service）入门** JMS是Java平台中用于消息传递的一个标准接口，它定义了在Java应用程序之间交换消息的API。通过JMS，开发者可以创建、发送、接收和阅读异步消息，这对于分布式系统中的解耦和...

    activemq与spring整合发送jms消息入门实例

    本教程将深入探讨如何将这两个强大的工具结合在一起，以创建一个简单的发送JMS消息的入门实例。 首先，我们需要理解ActiveMQ的基本概念。ActiveMQ是Apache软件基金会开发的一个开源消息代理，它实现了JMS规范，提供...

    javax.jms.jar

    Classes contained in javax.jms.jar: javax.transaction.xa.XAResource.class javax.jms.BytesMessage.class javax.jms.Message.class javax.jms.JMSException.class javax.jms.Destination.class javax.jms....

    JMS demo 及 资料

    在"JMS入门级的蹩脚篇.ppt"这个文件中，可能包含了以下内容：JMS的基本概念解释，如何创建消息，如何设置消息队列和主题，如何编写生产者和消费者代码示例，以及如何配置和运行JMS应用程序。这些内容对于初学者理解...

    JMS（JMS（JMS（JMS（

    JMS（JMS（JMS（JMS（JMS（JMS（JMS（JMS（JMS（JMS（JMS（JMS（JMS（JMS（JMS（JMS（JMS（JMS（JMS（JMS（JMS（JMS（JMS（JMS（JMS（JMS（JMS（JMS（JMS（JMS（JMS（JMS（JMS（JMS（JMS

    javax.jms.jar下载

    javax.jms.BytesMessage.class javax.jms.Connection.class javax.jms.ConnectionConsumer.class javax.jms.ConnectionFactory.class javax.jms.ConnectionMetaData.class javax.jms.DeliveryMode.class javax.jms....

    spring jms tomcat 异步消息传递入门实例

    在这个"spring jms tomcat 异步消息传递入门实例"中，我们将探讨如何在Spring框架下利用JMS和Tomcat实现异步消息传递，以提高系统性能和可扩展性。 首先，理解异步消息传递的概念至关重要。在同步通信中，发送方...

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