JMS基础 - 精华版

JMS基础(1)

1. 消息中间件: 将信息以消息的形式,从一个应用程序传送到另一个或多个应用程序。

  主要特点:

                   (1) 消息异步接收消息发送者不需要等待消息接收者的响应

                   (2) 消息可靠接收: 确保消息在中间件可靠保存,只有接收方收到后才能删除消息,多个消息可以组成原子事务。有时,也要求消息不能重复传输。


          为什么会出现消息中间件?

          各个系统同步发送接收数据,相互等待,造成系统瓶颈。

  

JMS使用场景:
       第一想到的就是异步处理. 其实,还可以用JMS来解决很多复杂的问题, 例如分布, 并发, 系统解耦, 负载均衡, 热部署, 触发器等, 这些复杂的问题因为引入了JMS而变的更加简单.

        (1同步通信客户发出调用后,必须等待服务对象完成处理并返回结果后才能够继续执行。

              如果数据交互过程, 允许异步操作时, 可以考虑使用JMS

              比如: JMS来异步发送邮件数据的生产者交付数据后,即可立即返回而无需等待数据的执行结果,对于数据消费者可以在合适的时机接收数据并执行. 这一点可能是我们使用JMS的主要原因.

       (2) JMS解决分布问题的场景解决分布有两种类型:

             第一种消息是集中的, 但消息的处理是分布的. 

                          例如系统可能会被分为前台与后台, 这两个系统是部署在不同的网段里的.那么怎么把前台发生的业务通知后台系统呢? 前台系统在处理完业务请求后的同时发送一个消息到queue,后台系统的消息接收者接收到消息后立即处理.这里消息的处理也可能有一定的延期,但这主要取决于消息服务器的硬件能力,网络带宽,消息接收者的处理速度等.

             第二种消息是分布的消息中间件提供了消息路由的功能。 

                         消息发送到一个消息服务器后, 这个消息服务器根据定义的规则再把这条消息路由转发到其它的消息服务器。例如, 可能在北京的一个数据中心部署了数据采集系统, 采集到数据后以消息的方式发送到消息服务器, 然后消息服务器再把这条消息路由到上海的数据中心, 再由上海数据中心部署的数据处理系统来处理这条消息.
       (3) 如果数据交互的双端执行效率不对等时,可以考虑使用JMS

            主要场景为数据生产的速度非常高(比如队列),但是数据消费的速度相对较低,如果没有良好的架构设计,必将对数据生产者造成阻塞或者数据积压,从而对整体的性能带来挑战或者数据安全带来风险; JMS就是一个很好的"数据缓冲"中心,它将密集的数据提交操作以"均匀"的速度交付给数据消费者, 从而实现系统整体的稳定性.  

             这种策略, 在日志统计/小数据分析系统中,经常使用. 主要作用为"缓解系统瓶颈,提高生产效率".

        

        归纳为: "异步调用、分布、应用解耦".

  


2. JMS基本概念

        JMS(Java Message Service) Java消息服务。JMSSUN提出的旨在统一各种消息中间件(MOM)系统接口的规范。它提供标准的产生、发送、接收消息的接口, 简化企业应用的开发。它支持两种消息通信模型:点到点(point-to-point)(P2P)模型和发布/订阅(Pub/Sub)模型。 

       

       点到点模型(P2P): 消息生产者产生一个消息后,把这个消息发送到一个Queue(队列)中,然后消息接收者再从这个Queue中读取,一旦这个消息被一个接收者读取之后,它就在这个Queue中消失了P2P模型规定一个消息只能有一个接收者, 即: 一个消息只能被一个接收者消费。

        发布/订阅模型(Pub/Sub): 消息生产者产生一个消息后,把这个消息发送到一个Topic中,这个Topic可以同时有多个接收者在监听,当一个消息到达这个Topic之后,所有消息接收者都会收到这个消息。Pub/Sub 模型允许一个消息可以有多个接收者。

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

 

JMS定义了2种模型

        (1) P2P: point-to-point, 即点对点消息传输模型

        (2) Pub/sub: publish-subscribe, 发布订阅模型

              P2P如下图所示:

                     

            如图可以看出一个或多个生产者发送消息消息m2先抵达queue, 消息m1后抵达queue, 它们一同存在于一个先进先出的queue里面消费者也存在一个或多个queue里面的消息进行消费。但消息被随机的一个消费者消费,且仅消费一次。

            点对点消息传递域的特点

             (1) 每个消息只能有一个消费者

             (2) 消息的生产者和消费者之间没有时间上的相关性。无论消费者在生产者发送消息的时候是否处于运行状态,它都可以提取消息。

             

              在pub/sub消息模型中消息被广播给所有的订阅者:

                     

              特点: 每个消息可以有多个消费者

 

JMS基础(2)

几个重要概念:

        Destination: 消息发送的目的地,destination2: QueueTopic。创建好一个消息之后,只需要把这个消息发送到目的地,消息的发送者就可以继续做自己的事情,而不用等待消息被处理完成。至于这个消息什么时候,会被哪个消费者消费,完全取决于消息的接受者。

        Message被发送的消息。它有下面几种类型:

        TextMessage 普通字符串消息,包含一个String
        ObjectMessage 对象消息,包含一个可序列化的Java 对象

        MapMessage 一个Map类型的消息,key为string 类型,而值为Java的基本类型。
        StreamMessage:  Java 数据流消息,用标准流操作来顺序的填充和读取。
        BytesMessage 二进制数组消息,包含一个byte[]
        XMLMessage:   一个XML类型的消息。


        最常用的是TextMessageObjectMessage

        ConnectionJMS提供者建立的一个连接。可以从这个连接创建一个会话,即Session
        ConnectionFactory:那如何创建一个Connection呢?

                                       通过工厂类就可以得到一个与JMS提供者的连接,即Conection

        SessionJMS提供者所建立的会话,通过Session我们才可以创建一个Message
        Producer消息的生产者,要发送一个消息,必须通过这个生产者来发送。
        MessageConsumer与生产者相对应,这是消息的消费者或接收者,通过它来接收一个消息。
   

        JMS给我们提供的只是一系列接口,当我们使用一个JMS的时候,还是需要一个第三方的提供者(ActiveMQ),它的作用就是真正管理这些ConnectionSessionTopicQueue等。

        通过上图可以看出上面这些概念的关系:

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

        

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

使用 JMS, 首先需要选择一个JMS提供者如果在JavaEE环境中可以不用考虑这些我们选择ActiveMQ, 官方地址http://activemq.apache.org/

                        

Java基础(3)

       一个消息对象分为三部分: 消息头(Headers)属性(Properties)和消息体(Payload)。

       对于StreamMessage和 MapMessage,消息本身就有特定的结构,而对于TextMessageObjectMessageBytesMessage是无结构的。一个消息可以包含一些重要的数据或者仅仅是一个事件的通知。

    

       消息的Headers部分通常包含一些消息的描述信息:

  JMSDestination: 消息的目的地,TopicQueue

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

       JMSTimestamp: 当调用send()方法的时候,JMSTimestamp会被自动设置为当前事件。可以通过下面方式得到这个值:long timestamp = message.getJMSTimestamp();

       JMSExpiration: 表示一个消息的有效期。只有在这个有效期内,消息消费者才可以消费这个消息。默认值为0,表示消息永不过期。可以通过下面的方式设置:
            producer.setTimeToLive(3600000); //有效期1小时(1000毫秒*60*60)

  JMSPriority: 消息的优先级。0-4为正常的优先级,5-9为高优先级。可以通过下面方式设置:   producer.setPriority(9);

  JMSMessageID: 一个字符串用来唯一标示一个消息。
  JMSReplyTo有时消息生产者希望消费者回复一个消息,JMSReplyTo为一个Destination,表示需要回复的目的地。当然消费者可以不理会它。
  JMSCorrelationID: 通常用来关联多个Message。例如需要回复一个消息,可以把JMSCorrelationID设置为所收到的消息的JMSMessageID
  JMSType表示消息体的结构,和JMS提供者有关。
  JMSRedelivered: 如果这个值为true,表示消息是被重新发送了。因为有时消费者没有确认他已经收到消息或者JMS提供者不确定消费者是否已经收到。

       除了Header,消息发送者可以添加一些属性(Properties)。这些属性可以是应用自定义的属性,JMS定义的属性和JMS提供者定义的属性。我们通常只适用自定义的属性。

 

 

 消息接收

         消费者接收消息可以采用两种方式:

         消息的同步和异步接收:

         (1) 消息的同步接收:   指客户端主动去接收消息,客户端可以采用MessageConsumer receive方法去接收下一个消息。    

         (2) 消息的异步接收:   指当消息到达时,ActiveMQ主动通知客户端。客户端可以通过注册一个实现MessageListener 接口的对象到MessageConsumerMessageListener只有一个必须实现的方法 —— onMessage,它只接收一个参数,即Message。在为每个发送到Destination的消息实现onMessage时,将调用该方法。 

              1consumer.receive() 或 consumer.receive(int timeout)
              2实现一个MessageListener接口

                 采用第一种方式,消息的接收者会一直等待下去,直到有消息到达,或者超时。

                 后一种方式会注册一个监听器,当有消息到达的时候,会回调它的onMessage()方法。

         

        举例说明:

                        MessageConsumer comsumer = session.createConsumer(queue);

                        comsumer.setMessageListener(new MessageListener(){
                        public void onMessage(Message msg) {
                               TextMessage textMsg = (TextMessage) msg;
                                 try {
                                       System.out.println(textMsg.getText());
                                 } catch (JMSException e) {
                                       e.printStackTrace();
                               }
                               }

                      });

   

        Queue实现的是点到点模型,在下面的例子中,启动2个消费者共同监听一个Queue,然后循环给这个Queue中发送多个消息,我们依然采用ActiveMQ

public class QueueTest {
     public static void main(String[] args) throws Exception {
        
ActiveMQConnectionFactory factory = new ActiveMQConnectionFactory("vm://localhost");

          Connection connection = factory.createConnection();
          connection.start();
       

         Queue queue = new ActiveMQQueue("testQueue");      //创建一个Queue, 每个消息只被消费了一次

         Topic topic= new ActiveMQTopic("testTopic");       //创建一个Topic每一个消息都会被所有的消费者消费

 

         Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
       

       //注册消费者1
       MessageConsumer comsumer1 = session.createConsumer(queue);
       comsumer1.setMessageListener(new MessageListener(){
            public void onMessage(Message msg) {
                try {
                    System.out.println("Consumer1 get:" + ((TextMessage)msg).getText());
                } catch (JMSException e) {
                    e.printStackTrace();
                }
            }
        });
       

        //注册消费者2
        MessageConsumer comsumer2 = session.createConsumer(queue);
        comsumer2.setMessageListener(new MessageListener(){
            public void onMessage(Message msg) {
                try {
                    System.out.println("Consumer2 get:" + ((TextMessage)msg).getText());
                } catch (JMSException e) {
                    e.printStackTrace();
                }
            }
           
        });
       

        //创建一个生产者
        MessageProducer producer = session.createProducer(queue);
        for(int i=0; i<10; i++){
            producer.send(session.createTextMessage("Message:" + i));
        }
    }
}


运行这个例子会得到下面的输出结果:

Consumer1 get Message:0
Consumer2 get Message:1
Consumer1 get Message:2
Consumer2 get Message:3
Consumer1 get Message:4
Consumer2 get Message:5


可以看出
:

        (1) 每个消息只能被消费一次

      (2) 如果有多个消费者同时监听一个Queue的话, 

           无法确定一个消息最终会被哪一个消费者消费。



 Java基础(4)

        JMSReplyTo, 在下面的例子中,首先创建两个Queue,发送者给一个Queue发送,接收者接收到消息之后给另一个Queue回复一个Message,然后再创建一个消费者来接受所回复的消息。
public class MessageSendReceiveAndReply {
    public static void main(String[] args) throws Exception {

        ActiveMQConnectionFactory factory = new ActiveMQConnectionFactory("vm://localhost");
   
        Connection connection = factory.createConnection();
        connection.start();
       
        //消息发送到这个Queue
        Queue queue = new ActiveMQQueue("testQueue");

         //消息回复到这个Queue
        Queue replyQueue = new ActiveMQQueue("replyQueue");
       
        final Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);

         //创建一个消息,并设置它的JMSReplyToreplyQueue
        Message message = session.createTextMessage("Andy");
        message.setJMSReplyTo(replyQueue);
       
        MessageProducer producer = session.createProducer(queue);
        producer.send(message);
           
        //消息的接收者
        MessageConsumer comsumer = session.createConsumer(queue);
        comsumer.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 e1) {
                    e1.printStackTrace();
                }
            }
           
         });
       
         //这个接收者用来接收回复的消息
        MessageConsumer comsumer2 = session.createConsumer(replyQueue);
        comsumer2.setMessageListener(new MessageListener(){
            public void onMessage(Message m) {
                try {
                    System.out.println(((TextMessage) m).getText());
                } catch (JMSException e) {
                    e.printStackTrace();
                }
            }
        });
    }
}
      首先消息生产者发送一个消息,内容为“Andy”, 然后消费者收到这个消息之后根据消息的JMSReplyTo,回复一个消息,内容为“Hello Andy‘。 最后在回复的Queue上创建一个接收回复消息的消费者,它输出所回复的内容。
    运行上面的程序,可以得到下面的输出结果:
      Hello Andy

  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值