JMS 入门

来源：互联网发布：重庆大数据招聘编辑：程序博客网时间：2024/06/05 04:15

JMS 入门(一) 基础

1. JMS基本概念

    JMS(Java Message Service) 即Java消息服务。它提供标准的产生、发送、接收消息的接口，简化企业应用的开发。它支持两种消息通信模型：点到点（point-to-point）（P2P）模型和发布/订阅（Pub/Sub）模型。P2P 模型规定了一个消息只能有一个接收者;Pub/Sub 模型允许一个消息可以有多个接收者。
    对于点到点模型，消息生产者产生一个消息后，把这个消息发送到一个Queue（队列）中，然后消息接收者再从这个Queue中读取，一旦这个消息被一个接收者读取之后，它就在这个Queue中消失了，所以一个消息只能被一个接收者消费。
    与点到点模型不同，发布/订阅模型中，消息生产者产生一个消息后，把这个消息发送到一个Topic中，这个Topic可以同时有多个接收者在监听，当一个消息到达这个Topic之后，所有消息接收者都会收到这个消息。

总结：简单的讲，点到点模型和发布/订阅模型的区别就是前者是一对一，后者是一对多。

2.几个重要概念

1）Destination：消息发送的目的地，也就是前面说的Queue和Topic。创建好一个消息之后，只需要把这个消息发送到目的地，消息的发送者就可以继续做自己的事情，而不用等待消息被处理完成。至于这个消息什么时候，会被哪个消费者消费，完全取决于消息的接受者。

2）Message：从字面上就可以看出是被发送的消息。它有下面几种类型：
        A）StreamMessage：Java 数据流消息，用标准流操作来顺序的填充和读取。
        B）MapMessage：一个Map类型的消息；名称为 string 类型，而值为 Java 的基本类型。
        C）TextMessage：普通字符串消息，包含一个String。
        D）ObjectMessage：对象消息，包含一个可序列化的Java 对象
        E）BytesMessage：二进制数组消息，包含一个byte[]。
        F）XMLMessage: 一个XML类型的消息。
      备注：其中最常用的是TextMessage和ObjectMessage。

3）Session：与JMS提供者所建立的会话，通过Session我们才可以创建一个Message。
4） Connection：与JMS提供者建立的一个连接。可以从这个连接创建一个会话，即Session。
5） ConnectionFactory:那如何创建一个Connection呢？这就需要下面讲到的ConnectionFactory了。通过这个工厂类就可以得到一个与JMS提供者的连接，即Conection。6）Producer：消息的生产者，要发送一个消息，必须通过这个生产者来发送。
7）MessageConsumer：与生产者相对应，这是消息的消费者或接收者，通过它来接收一个消息。
前面多次提到JMS提供者，因为JMS给我们提供的只是一系列接口，当我们使用一个JMS的时候，还是需要一个第三方的提供者，它的作用就是真正管理这些Connection，Session，Topic和Queue等。

通过下面这个简图可以看出上面这些概念的关系。

ConnectionFactory---->Connection--->Session--->Message
Destination + Session------------------------------------>Producer
Destination + Session------------------------------------>MessageConsumer

那么可能有人会问: ConnectionFactory和Destination 从哪儿得到?
这就和JMS提供者有关了. 如果在一个JavaEE环境中, 可以通过JNDI查找得到, 如果在一个非JavaEE环境中, 那只能通过JMS提供者提供给我们的接口得到了.

JMS 入门(二) 简单例子

1.前一讲简单的介绍了一下JMS的基本概念, 这一讲结合一个例子让大家深入理解前一讲的基本概念. 首先需要做的是选择一个JMS提供者, 如果在JavaEE环境中可以不用考虑这些. 我们选择ActiveMQ, 官方地址: http://activemq.apache.org/. 网上有很多介绍ActiveMQ的文档, 所以在这里就不介绍了.
2.按照上一讲的这个简图：
ConnectionFactory---->Connection--->Session--->Message
Destination + Session------------------------------------>Producer
Destination + Session------------------------------------>MessageConsumer
A）首先需要得到ConnectionFactoy和Destination，这里创建一个一对一的Queue作为Destination。
ConnectionFactory factory = new ActiveMQConnectionFactory("vm://localhost");
Queue queue = new ActiveMQQueue("testQueue");
B）然后又ConnectionFactory创建一个Connection, 再启动这个Connection:
Connection connection = factory.createConnection();
connection.start();
C）接下来需要由Connection创建一个Session:
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE)
现在暂且不用管参数的含义, 以后会详细讲到.
D）下面就可以创建Message了,这里创建一个TextMessage。
Message message = session.createTextMessage("Hello JMS!");
E）要想把刚才创建的消息发送出去，需要由Session和Destination创建一个消息生产者：
MessageProducer producer = session.createProducer(queue);
F）下面就可以发送刚才创建的消息了：
producer.send(message);
G）消息发送完成之后，我们需要创建一个消息消费者来接收这个消息：
MessageConsumer comsumer = session.createConsumer(queue);
Message recvMessage = comsumer.receive();
H）消息消费者接收到这个消息之后，就可以得到它的内容：

System.out.println(((TextMessage)recvMessage).getText());

3.至此，一个简单的JMS例子就完成了。下面是全部源码：

/** * @author Administrator * @desctiption 结合一个例子，深入理解JMS的基本概念 * 消息的消费者接收消息可以采用两种方式： * 1、consumer.receive() 或 consumer.receive(int timeout)； * 2、注册一个MessageListener。 * 采用第一种方式，消息的接收者会一直等待下去，直到有消息到达，或者超时。 * 后一种方式会注册一个监听器，当有消息到达的时候，会回调它的onMessage()方法。 */package com.wl.jms;import javax.jms.Connection;import javax.jms.ConnectionFactory;import javax.jms.JMSException;import javax.jms.Message;import javax.jms.MessageConsumer;import javax.jms.MessageListener;import javax.jms.MessageProducer;import javax.jms.Queue;import javax.jms.Session;import javax.jms.TextMessage;import org.apache.activemq.ActiveMQConnectionFactory;import org.apache.activemq.command.ActiveMQQueue;public class MessageSendAndReceive {/** * @param args * @throws JMSException  */public static void main(String[] args) throws JMSException {// TODO Auto-generated method stubConnectionFactory factory = new ActiveMQConnectionFactory("vm://localhost");               Connection connection = factory.createConnection();          connection.start();          //创建消息的Destination         Queue queue = new ActiveMQQueue("testQueue");                   final Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);         //创建将要发送的消息        Message message = session.createTextMessage("Hello JMS!");          //创建消息生产者发送消息         MessageProducer producer = session.createProducer(queue);          producer.send(message);               System.out.println("Send Message Completed!");          //创建消息的接收者         MessageConsumer comsumer = session.createConsumer(queue);         //消息的消费者接收消息的第一种方式：consumer.receive() 或 consumer.receive(int timeout)；        //Message recvMessage = comsumer.receive();          //System.out.println(((TextMessage)recvMessage).getText());         //消息的消费者接收消息的第二种方式：注册一个MessageListener        comsumer.setMessageListener(new MessageListener(){public void onMessage(Message msg) {// TODO Auto-generated method stubTextMessage textMsg=(TextMessage)msg;try {System.out.println(textMsg.getText());} catch (JMSException e) {e.printStackTrace();}}                });}}

JMS入门(三) Queue 的使用

Queue实现的是点到点模型，一个点对点 (PTP) 的产品或者应用是基于消息队列、发送者和接收者的概念来构建的。每个消息被定为到一个特定的队列，接收者从队列中提取发送给它的消息，队列将保留所有的消息直到消息被取走或者过期。

1）每个消息只有唯一一个接收者（消费者）

2）消息的发送者和接收者没有时间上的依赖，接收者可在消息过期前的任意时间内去获取消息，而不一定得发送者是在线的

3）接收者需要确认成功的处理了消息

在下面的例子中，启动2个消费者共同监听一个Queue，然后循环给这个Queue中发送多个消息，我们依然采用ActiveMQ。

直接上代码了：

[java] view plaincopy
/** 
 * @author Administrator 
 * @description Queue实现的是点到点模型，在下面的例子中，启动2个消费者共同监听一个Queue，然后循环给这个Queue中发送多个消息，我们依然采用ActiveMQ 
 * 结果表明：可以看出每个消息直被消费了一次，但是如果有多个消费者同时监听一个Queue的话，无法确定一个消息最终会被哪一个消费者消费 
 */  
package com.wl.jms;  
  
import javax.jms.Connection;  
import javax.jms.JMSException;  
import javax.jms.Message;  
import javax.jms.MessageConsumer;  
import javax.jms.MessageListener;  
import javax.jms.MessageProducer;  
import javax.jms.Queue;  
import javax.jms.Session;  
import javax.jms.TextMessage;  
  
import org.apache.activemq.ActiveMQConnectionFactory;  
import org.apache.activemq.command.ActiveMQQueue;  
  
public class QueueTest {  
  
    /** 
     * @param args 
     * @throws JMSException  
     */  
    public static void main(String[] args) throws JMSException {  
        // TODO Auto-generated method stub  
        ActiveMQConnectionFactory factory=new ActiveMQConnectionFactory("vm://localhost");  
        Connection connection=factory.createConnection();  
        connection.start();  
        //创建一个Queue  
        Queue queue=new ActiveMQQueue("testQueue");  
        //创建一个Session  
        Session session=connection.createSession(false, Session.AUTO_ACKNOWLEDGE);  
        //注册消费者1  
        MessageConsumer consumer1=session.createConsumer(queue);  
        consumer1.setMessageListener(new MessageListener(){  
            public void onMessage(Message m) {  
                try {  
                    System.out.println("Consumer1 get: "+((TextMessage)m).getText());  
                } catch (JMSException e) {  
                    e.printStackTrace();  
                }  
            }  
              
        });  
        //注册消费者2  
        MessageConsumer consumer2=session.createConsumer(queue);  
        consumer2.setMessageListener(new MessageListener(){  
            public void onMessage(Message m) {  
                try {  
                    System.out.println("Consumer2 get: "+((TextMessage)m).getText());  
                } catch (JMSException e) {  
                    e.printStackTrace();  
                }  
            }  
              
        });  
        //创建一个生产者，然后发送多个消息。  
        MessageProducer producer=session.createProducer(queue);  
        for(int i=0;i<10;i++){  
            producer.send(session.createTextMessage("Message:"+i));  
        }  
    }  
  
}  

此程序的运行结果：

JMS入门（四）--Topic的使用

与Queue不同的是，Topic实现的是发布/订阅模型，

在一个基于发布/订阅模型的应用或者产品中，客户端根据主题来订阅消息，有点像公告牌。发布者和订阅者一般都是匿名的，而且可以动态的发布或者订阅内容。消息系统会谨慎处理消息的分发到订阅了某个主题的所有订阅者，消息只会发送给当前订阅者，然后就失效，新的订阅者无法接收到刚刚失效的消息。

发布和订阅的消息机制具有以下特征：

1）每个消息可以有多个消费者

2）发布者和订阅者是有时间依赖，只有当前订阅了某个主题的订阅者才能收到消息，订阅者必须保持活跃以获取消息

3）当一个消息可能会有多于1个的接收者是，请使用发布/订阅消息机制。

在下面的例子中，启动2个消费者共同监听一个Topic，然后循环给这个Topic中发送多个消息。

具体的代码如下：

/** * @author Administrator * @description 与Queue不同的是，Topic实现的是发布/订阅模型，在下面的例子中，启动2个消费者共同监听一个Topic，然后循环给这个Topic中发送多个消息 * 结果表明：说明每一个消息都会被所有的消费者消费 */package com.wl.jms;import javax.jms.Connection;import javax.jms.JMSException;import javax.jms.Message;import javax.jms.MessageConsumer;import javax.jms.MessageListener;import javax.jms.MessageProducer;import javax.jms.Session;import javax.jms.TextMessage;import javax.jms.Topic;import org.apache.activemq.ActiveMQConnectionFactory;import org.apache.activemq.command.ActiveMQTopic;public class TopicTest {/** * @param args * @throws JMSException  */public static void main(String[] args) throws JMSException {// TODO Auto-generated method stubActiveMQConnectionFactory factory=new ActiveMQConnectionFactory("vm://localhost");Connection connection=factory.createConnection();connection.start();//创建一个TopicTopic topic=new ActiveMQTopic("testTopic");Session session=connection.createSession(false, Session.AUTO_ACKNOWLEDGE);//注册消费者1MessageConsumer consumer1=session.createConsumer(topic);consumer1.setMessageListener(new MessageListener(){public void onMessage(Message m) {try {System.out.println("Consumer1 get: "+((TextMessage)m).getText());} catch (JMSException e) {e.printStackTrace();}}});//注册消费者2MessageConsumer consumer2=session.createConsumer(topic);consumer2.setMessageListener(new MessageListener(){public void onMessage(Message m) {try {System.out.println("Consumer2 get: "+((TextMessage)m).getText());} catch (JMSException e) {e.printStackTrace();}}});//创建一个生产者，然后发送多个消息。MessageProducer producer=session.createProducer(topic);for(int i=0;i<10;i++){producer.send(session.createTextMessage("Message:"+i));}}}

运行结果如下：

JMS入门（五）--消息头

一个消息对象分为三部分：消息头(Headers)，属性（Properties）和消息体（Payload）。对于StreamMessage和MapMessage，消息本身就有特定的结构，而对于TextMessage，ObjectMessage和BytesMessage是无结构的。一个消息可以包含一些重要的数据或者仅仅是一个事件的通知。
消息的Headers部分通常包含一些消息的描述信息，它们都是标准的描述信息。包含下面一些值：
　　1）JMSDestination
消息的目的地，Topic或者是Queue。
　　2）JMSDeliveryMode

消息的发送模式：persistent或nonpersistent。前者表示消息在被消费之前，如果JMS提供者DOWN了，重新启动后消息仍然存在。后者在这种情况下表示消息会被丢失。可以通过下面的方式设置：Producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT);

       3）JMSTimestamp
       当调用send()方法的时候，JMSTimestamp会被自动设置为当前事件。可以通过下面方式得到这个值：
       long timestamp = message.getJMSTimestamp();
　　4）JMSExpiration
       表示一个消息的有效期。只有在这个有效期内，消息消费者才可以消费这个消息。默认值为0，表示消息永不过期。可以通过下面的方式设置：
       producer.setTimeToLive(3600000); //有效期1小时（1000毫秒 * 60秒 * 60分）
　　5）JMSPriority
       消息的优先级。0-4为正常的优先级，5-9为高优先级。可以通过下面方式设置：
       producer.setPriority(9);
　　6）JMSMessageID
       一个字符串用来唯一标示一个消息。
　　7）JMSReplyTo
       有时消息生产者希望消费者回复一个消息，JMSReplyTo为一个Destination，表示需要回复的目的地。当然消费者可以不理会它。
　　8）JMSCorrelationID
       通常用来关联多个Message。例如需要回复一个消息，可以把JMSCorrelationID设置为所收到的消息的JMSMessageID。
　　9）JMSType
       表示消息体的结构，和JMS提供者有关。
　　10）JMSRedelivered
       如果这个值为true，表示消息是被重新发送了。因为有时消费者没有确认他已经收到消息或者JMS提供者不确定消费者是否已经收到。
    除了Header，消息发送者可以添加一些属性(Properties)。这些属性可以是应用自定义的属性，JMS定义的属性和JMS提供者定义的属性。我们通常只适用自定义的属性。

JMS入门（六）--DeliveryMode

1.在下面的例子中，分别发送一个Persistent和nonpersistent的消息，然后关闭退出JMS。

发送端代码如下：

/** * @author Administrator * @description 分别发送一个Persistent和nonpersistent的消息，然后关闭退出JMS * 运行这个程序，当输出“Send messages sucessfully!”时，说明两个消息都已经发送成功，然后我们结束它，来停止JMS Provider。 */package com.wl.jms;import javax.jms.Connection;import javax.jms.DeliveryMode;import javax.jms.JMSException;import javax.jms.MessageProducer;import javax.jms.Queue;import javax.jms.Session;import org.apache.activemq.ActiveMQConnectionFactory;import org.apache.activemq.command.ActiveMQQueue;public class DeliveryModeSendTest {/** * @param args * @throws JMSException  */public static void main(String[] args) throws JMSException {// TODO Auto-generated method stubActiveMQConnectionFactory factory=new ActiveMQConnectionFactory("vm://localhost");Connection connection=factory.createConnection();connection.start();Queue queue=new ActiveMQQueue("testQueue");Session session=connection.createSession(false, Session.AUTO_ACKNOWLEDGE);//创建一个消息的生产者MessageProducer producer=session.createProducer(queue);//设置消息的DeliveryMode为Persistentproducer.setDeliveryMode(DeliveryMode.PERSISTENT);producer.send(session.createTextMessage("A persistent Message"));//设置消息的DeliveryMode为Non-Persistentproducer.setDeliveryMode(DeliveryMode.NON_PERSISTENT);producer.send(session.createTextMessage("A non persistent Message"));System.out.println("Send messages successfully!");}}

运行上面的程序，结果如下：

当输出“Send messages sucessfully!”时，说明两个消息都已经发送成功，然后我们结束它，来停止JMS Provider。
2. 接下来我们重新启动JMS Provicer，然后添加一个消费者：

/** * @author Administrator * @description 这个程序是基于DeliveryModeSendTest基础上来做的 * 运行上面的程序，可以得到下面的输出结果：Consumer get：A persistent Message * 可以看出消息消费者只接收到一个消息，它是一个Persistent的消息。而刚才发送的non persistent消息已经丢失了。 */package com.wl.jms;import javax.jms.Connection;import javax.jms.JMSException;import javax.jms.Message;import javax.jms.MessageConsumer;import javax.jms.MessageListener;import javax.jms.Queue;import javax.jms.Session;import javax.jms.TextMessage;import org.apache.activemq.ActiveMQConnectionFactory;import org.apache.activemq.command.ActiveMQQueue;public class DeliveryModeReceiveTest {/** * @param args * @throws JMSException  */public static void main(String[] args) throws JMSException {// TODO Auto-generated method stubActiveMQConnectionFactory factory=new ActiveMQConnectionFactory("vm://localhost");Connection connection=factory.createConnection();connection.start();Queue queue=new ActiveMQQueue("testQueue");Session session=connection.createSession(false, Session.AUTO_ACKNOWLEDGE);//创建消息的接收者，来接受DeliveryModeSendTest中发送的消息MessageConsumer consumer=session.createConsumer(queue);consumer.setMessageListener(new MessageListener(){public void onMessage(Message m) {// TODO Auto-generated method stubtry {System.out.println("Consumer get: "+((TextMessage)m).getText());} catch (JMSException e) {// TODO Auto-generated catch blocke.printStackTrace();}}});}}

运行这个接受端的程序，结果如下：

可以看出消息消费者只接收到一个消息，它是一个Persistent的消息。而刚才发送的non persistent消息已经丢失了。
另外, 如果发送一个non persistent消息, 而刚好这个时候没有消费者在监听, 这个消息也会丢失.

JMS入门（七）---JMSReplyTo

在下面的例子中，首先创建两个Queue，发送者给一个Queue发送，接收者接收到消息之后给另一个Queue回复一个Message，然后再创建一个消费者来接受所回复的消息。

[java] view plaincopy
/** 
 * @author Administrator 
 * @description:首先创建两个Queue，发送者给一个Queue发送，接收者接收到消息之后给另一个Queue回复一个Message，然后再创建一个消费者来接受所回复的消息 
 */  
package com.wl.jms;  
  
import javax.jms.Connection;  
import javax.jms.JMSException;  
import javax.jms.Message;  
import javax.jms.MessageConsumer;  
import javax.jms.MessageListener;  
import javax.jms.MessageProducer;  
import javax.jms.Queue;  
import javax.jms.Session;  
import javax.jms.TextMessage;  
  
import org.apache.activemq.ActiveMQConnectionFactory;  
import org.apache.activemq.command.ActiveMQQueue;  
  
public class MessageSendReceiveAndReply {  
  
    /** 
     * @param args 
     * @throws JMSException  
     */  
    public static void main(String[] args) throws JMSException {  
        // TODO Auto-generated method stub  
        ActiveMQConnectionFactory factory=new ActiveMQConnectionFactory("vm://localhost");  
        Connection connection=factory.createConnection();  
        connection.start();  
        //消息发送到这个Queue  
        Queue queue=new ActiveMQQueue("testQueue");  
        //消息回复到这个Queue  
        Queue replyQueue=new ActiveMQQueue("replayQueue");  
        final Session session=connection.createSession(false, Session.AUTO_ACKNOWLEDGE);  
        //创建一个消息，并设置它的JMSReplayTo为replayQueue  
        Message message=session.createTextMessage("Andy");  
        message.setJMSReplyTo(replyQueue);  
        //创建一个生产者来发送这个消息  
        MessageProducer producer=session.createProducer(queue);  
        producer.send(message);  
        //消息的接收者  
        MessageConsumer consumer=session.createConsumer(queue);  
        consumer.setMessageListener(new MessageListener(){  
  
            public void onMessage(Message m) {  
                try {  
                    //创建一个新的MessageProducer来发送一个回复消息  
                    MessageProducer producer=session.createProducer(m.getJMSReplyTo());  
                    producer.send(session.createTextMessage("Hello "+((TextMessage)m).getText()));  
                } catch (JMSException e) {  
                    // TODO Auto-generated catch block  
                    e.printStackTrace();  
                }  
            }  
              
        });  
        //这个接收者用来接收回复的消息  
        MessageConsumer consumer2=session.createConsumer(replyQueue);  
        consumer2.setMessageListener(new MessageListener(){  
  
            public void onMessage(Message m) {  
                try {  
                    System.out.println(((TextMessage)m).getText());  
                } catch (JMSException e) {  
                    // TODO Auto-generated catch block  
                    e.printStackTrace();  
                }  
            }  
              
        });  
    }  
  
}  

首先消息生产者发送一个消息，内容为“Andy”，然后消费者收到这个消息之后根据消息的JMSReplyTo，回复一个消息，内容为“Hello Andy‘。最后在回复的Queue上创建一个接收回复消息的消费者，它输出所回复的内容。
运行上面的程序，可以得到下面的输出结果：

转自 :http://blog.csdn.net/wl_ldy/article/category/1216997

0 0