ActivityMQ中的使用详解

介绍基本的JMS概念与开源的JMS框架ActiveMQ应用,内容涵盖一下几点:

1.      基本的JMS概念

2.       JMS的消息模式

3.       介绍ActiveMQ

4.      一个基于ActiveMQ的JMS例子程序

一:JMS基本概念

1.      JMS的目标

        为企业级的应用提供一种智能的消息系统,JMS定义了一整套的企业级的消息概念与工具,

        尽可能最小化的Java语言概念去构建最大化企业消息应用。统一已经存在的企业级消息系

        统功能。

2.      JMS提供者

        JMS提供者是指那些完全完成JMS功能与管理功能的JMS消息厂商,理论上JMS提供者完成 

        JMS消息产品必须是100%的纯Java语言实现,可以运行在跨平台的架构操作系统上,当前

        一些JMS厂商包括IBM,Oracle, JBoss社区 (JBoss Community), Apache 社区(ApacheCommunity)。

3.      JMS应用程序, 一个完整的JMS应用应该实现以下功能:

         JMS 客户端 – Java语言开发的接受与发送消息的程序

         非JMS客户端 – 基于消息系统的本地API实现而不是JMS

         消息 – 应用程序用来相互交流信息的载体

          被管理对象–预先配置的JMS对象,JMS管理员创建,被客户端运用。如链接工厂,主题等

         JMS提供者–完成JMS功能与管理功能的消息系统

 

二:JMS的消息模式

1.      点对点的消息模式(Point to Point Messaging)


下面的JMS对象在点对点消息模式中是必须的:

a.      队列(Queue) – 一个提供者命名的队列对象,客户端将会使用这个命名的队列对象

b.     队列链接工厂(QueueConnectionFactory) – 客户端使用队列链接工厂创建链接队列

        ConnectionQueue来取得与JMS点对点消息提供者的链接。

c.      链接队列(ConnectionQueue) – 一个活动的链接队列存在在客户端与点对点消息提供者之

        间,客户用它创建一个或者多个JMS队列会话(QueueSession)

d.     队列会话(QueueSession) – 用来创建队列消息的发送者与接受者(QueueSenderand

         QueueReceiver)

e.     消息发送者(QueueSender 或者MessageProducer)– 发送消息到已经声明的队列

f.       消息接受者(QueueReceiver或者MessageConsumer) – 接受已经被发送到指定队列的消息

2.      发布订阅模式(publish – subscribe Mode)


a.      主题Topic(Destination) – 一个提供者命名的主题对象,客户端将会使用这个命名的主题对象

b.     主题链接工厂(TopciConnectionFactory) – 客户端使用主题链接工厂创建链接主题

         ConnectionTopic来取得与JMS消息Pub/Sub提供者的链接。

c.      链接主题(ConnectionTopic) – 一个活动的链接主题存在发布者与订阅者之间

d.     会话(TopicSession) – 用来创建主题消息的发布者与订阅者 (TopicPublisher  and

         TopicSubscribers)

e.     消息发送者MessageProducer) – 发送消息到已经声明的主题

f.       消息接受者(MessageConsumer) – 接受已经被发送到指定主题的消息

 

三:介绍ActiveMQ

ActiveMQ是apache社区完成的JMS开源消息组件,客户端支持多种语言调用,包括Java,C++, C#,

Perl, Python等。支持spring配置集成等。更多信息访问这里:

http://activemq.apache.org/index.html

四:基于ActiveMQ的Publish/subscribe模式Demo程序

消息Broker,JMSprovider

[java] view plain copy
  1. import java.net.URI;  
  2. import java.net.URISyntaxException;  
  3.   
  4. import javax.jms.Connection;  
  5. import javax.jms.ConnectionFactory;  
  6. import javax.jms.Destination;  
  7. import javax.jms.JMSException;  
  8. import javax.jms.MessageProducer;  
  9. import javax.jms.Session;  
  10. import javax.jms.TextMessage;  
  11. import javax.naming.Context;  
  12. import javax.naming.InitialContext;  
  13. import javax.naming.NamingException;  
  14.   
  15. import org.apache.activemq.broker.BrokerFactory;  
  16. import org.apache.activemq.broker.BrokerService;  
  17. import org.apache.commons.logging.Log;  
  18. import org.apache.commons.logging.LogFactory;  
  19.   
  20. /** 
  21.  * refer to http://activemq.apache.org/jndi-support.html 
  22.  * http://activemq.apache.org/how-do-i-embed-a-broker-inside-a-connection.html 
  23.  * @author gloomyfish 
  24.  * 
  25.  */  
  26. public class PureJMSProducer {  
  27.       
  28.     private static final Log LOG = LogFactory.getLog(PureJMSProducer.class);  
  29.   
  30.     private PureJMSProducer() {  
  31.     }  
  32.   
  33.     /** 
  34.      * @param args the destination name to send to and optionally, the number of 
  35.      *                messages to send 
  36.      */  
  37.     public static void main(String[] args) {  
  38.         Context jndiContext = null;  
  39.         ConnectionFactory connectionFactory = null;  
  40.         Connection connection = null;  
  41.         Session session = null;  
  42.         Destination destination = null;  
  43.         MessageProducer producer = null;  
  44.         BrokerService broker = null;  
  45.         final int numMsgs = 10;  
  46.   
  47.         /* 
  48.          * Create a JNDI API InitialContext object 
  49.          */  
  50.         try {  
  51.             jndiContext = new InitialContext();  
  52.         } catch (NamingException e) {  
  53.             LOG.info("Could not create JNDI API context: " + e.toString());  
  54.             System.exit(1);  
  55.         }  
  56.           
  57.         // create external TCP broker  
  58.         try {  
  59.             broker = BrokerFactory.createBroker(new URI("broker:tcp://localhost:61616"));  
  60.             broker.start();   
  61.         } catch (URISyntaxException e) {  
  62.             LOG.info("Could not create broker: " + e.toString());  
  63.         } catch (Exception e) {  
  64.             LOG.info("Could not create broker: " + e.toString());  
  65.         }  
  66. //        try {  
  67. //            
  68. //        }  
  69.   
  70.         /* 
  71.          * Look up connection factory and destination. 
  72.          */  
  73.         try {  
  74.             connectionFactory = (ConnectionFactory)jndiContext.lookup("ConnectionFactory");  
  75.             destination = (Destination)jndiContext.lookup("MyTopic");  
  76.         } catch (NamingException e) {  
  77.             LOG.info("JNDI API lookup failed: " + e);  
  78.             System.exit(1);  
  79.         }  
  80.           
  81.         /* 
  82.          * Create connection. Create session from connection; false means 
  83.          * session is not transacted. Create sender and text message. Send 
  84.          * messages, varying text slightly. Send end-of-messages message. 
  85.          * Finally, close connection. 
  86.          */  
  87.         try {  
  88.             connection = connectionFactory.createConnection();  
  89.             session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);  
  90.             producer = session.createProducer(destination);  
  91.             TextMessage message = session.createTextMessage();  
  92.             Thread.sleep(3000);  
  93.             for (int i = 0; i < numMsgs; i++) {  
  94.                 message.setText("This is message " + (i + 1));  
  95.                 LOG.info("Sending message: " + message.getText());  
  96.                 producer.send(message);  
  97.                 Thread.sleep(3000);  
  98.             }  
  99.   
  100.             /* 
  101.              * Send a non-text control message indicating end of messages. 
  102.              */  
  103.             producer.send(session.createMessage());  
  104.         } catch (JMSException e) {  
  105.             LOG.info("Exception occurred: " + e);  
  106.         } catch (InterruptedException e) {  
  107.             LOG.info("Exception occurred: " + e);  
  108.         } finally {  
  109.             if (connection != null) {  
  110.                 try {  
  111.                     connection.close();  
  112.                 } catch (JMSException e) {  
  113.                 }  
  114.             }  
  115.         }  
  116.           
  117.         // stop the TCP broker  
  118.         try {  
  119.             broker.stop();  
  120.         } catch (Exception e) {  
  121.             LOG.info("stop the broker failed: " + e);  
  122.         }  
  123.     }  
  124.   
  125.   
  126. }  
客户端:

[java] view plain copy
  1. import java.io.IOException;  
  2.   
  3. import javax.jms.Connection;  
  4. import javax.jms.JMSException;  
  5. import javax.jms.Message;  
  6. import javax.jms.MessageConsumer;  
  7. import javax.jms.MessageListener;  
  8. import javax.jms.Session;  
  9. import javax.jms.TextMessage;  
  10. import javax.jms.Topic;  
  11. import javax.naming.InitialContext;  
  12.   
  13. import org.apache.activemq.ActiveMQConnectionFactory;  
  14.   
  15.   
  16. public class ActiveMQClient {  
  17.       
  18.     public static void main(String[] args) throws IOException {  
  19.           
  20.         // -- http://dlc.sun.com/pdf//816-5904-10/816-5904-10.pdf  
  21.         try {  
  22.         ActiveMQConnectionFactory factory = new ActiveMQConnectionFactory("tcp://localhost:61616");  
  23.         // ActiveMQConnectionFactory factory = new ActiveMQConnectionFactory("vm://locahost");  
  24.         Connection connection = factory.createConnection();  
  25.         connection.start();  
  26.           
  27.         // create message topic  
  28.         //Topic topic= new ActiveMQTopic("MyTopic");  
  29.         InitialContext jndiContext=new InitialContext();  
  30.         Topic topic=(Topic)jndiContext.lookup("MyTopic");   
  31.         Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);  
  32.           
  33.         // register message consumer  
  34.         MessageConsumer comsumer1 = session.createConsumer(topic);  
  35.         comsumer1.setMessageListener(new MessageListener(){  
  36.             public void onMessage(Message m) {  
  37.                 try {  
  38.                     System.out.println("Consumer get " + ((TextMessage)m).getText());  
  39.                 } catch (JMSException e) {  
  40.                     e.printStackTrace();  
  41.                 }   
  42.             }  
  43.         });  
  44.         Thread.sleep(30000);  
  45.         session.close();  
  46.         connection.stop();  
  47.           
  48.         } catch(Exception e) {  
  49.             e.printStackTrace();  
  50.         }  
  51.     }  
  52.   
  53. }  
项目配置,Jar依赖:

依赖的三个Jar分别为:

  • activemq-all.jar
  • geronimo-jms_1.1_spec-1.1.1.jar
  • xbean-spring.jar

补充JNDI内容:

[html] view plain copy
  1. java.naming.factory.initial = org.apache.activemq.jndi.ActiveMQInitialContextFactory  
  2. java.naming.provider.url = tcp://localhost:61616  
  3. connectionFactory=topicConnectionFactry  
  4. topic.MyTopic = example.MyTopic  
展开阅读全文

没有更多推荐了,返回首页