jms消息机制，包括点对点、发布/订阅模式

最新推荐文章于 2022-05-06 17:49:58 发布
最新推荐文章于 2022-05-06 17:49:58 发布
阅读量1.2k 收藏 1
点赞数
分类专栏： jms消息服务 文章标签： jms activemq 发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013035314/article/details/44776501
版权
本文介绍了JMS（Java Message Service）的消息传递机制，涵盖点对点通信和发布/订阅模式。分别阐述了消息接收者和生产者在两种模式下的工作原理，详细解析了如何在点对点中实现一对一的消息传递，以及在发布/订阅模式下实现一对多的消息广播。
摘要由CSDN通过智能技术生成

一、消息接收者（点对点）

package recevers;


import Constants.Constant;
import org.apache.activemq.ActiveMQConnection;
import org.apache.activemq.ActiveMQConnectionFactory;


import javax.jms.*;


/**
 * jms消息接收者,点对点
 * Created with IntelliJ IDEA.
 * User: wxshi
 * Date: 15-3-6
 * Time: 下午4:58
 * To change this template use File | Settings | File Templates.
 */
public class QueueReceiver {


    private ConnectionFactory connectionFactory;    // ConnectionFactory ：连接工厂，JMS 用它创建连接
    private Connection connection;     // Connection ：JMS 客户端到JMS Provider 的连接
    private Session session;         // Session： 一个发送或接收消息的线程
    private Destination destination;       // Destination ：消息的目的地;消息发送给谁.


    public QueueReceiver(){
        try{
            connectionFactory = new ActiveMQConnectionFactory(
                    ActiveMQConnection.DEFAULT_USER,
                    ActiveMQConnection.DEFAULT_PASSWORD, Constant.MQ_URL);
            connection = connectionFactory.createConnection();    // 构造从工厂得到连接对象
            session = connection.createSession(Boolean.TRUE,Session.AUTO_ACKNOWLEDGE);  // 获取会话
            destination = session.createQueue(Constant.QUEUE);
            connection.start();  // 启动
        }catch (Exception e){
            e.printStackTrace();
        }
    }


    //接收消息并处理
    public void receiveMsg(){
        try {
            MessageConsumer consumer = null;        // 消费者，消息接收者
            String msgSelecter = "JMSCorrelationID='5' AND msgName='消息5'";   //定义消息选择器
            consumer = session.createConsumer(destination,msgSelecter);   //使用消息选择器创建接收者


           while (true) {
                // 设置接收者接收消息的时间，为了便于测试，这里谁定为100s
               Message message = consumer.receive(100000);
                if (null != message) {
                    if(message instanceof TextMessage){
                        System.out.println("收到text消息：" + ((TextMessage) message).getText());
                    }else if(message instanceof StreamMessage){
                        System.out.println("收到stream消息名：" + message.getStringProperty("streamName"));
                        System.out.println("收到stream消息内容：" + message.getStringProperty("streamContent"));
                    }else if(message instanceof MapMessage){
                        System.out.println("收到map消息名：" + message.getStringProperty("mapName"));
                        System.out.println("收到map消息内容：" + message.getStringProperty("mapContent"));
                    }else if(message instanceof ObjectMessage){
                        System.out.println("收到object消息：" + ((ObjectMessage) message).getObject().toString());
                    }
                    System.out.println("准备回复确认...");
                    System.out.println("----------------------------");
                    MessageProducer sender = session.createProducer(message.getJMSReplyTo());
                    TextMessage reqMsg =  session.createTextMessage("消费者已经消费消息0");
                    reqMsg.setJMSCorrelationID(message.getStringProperty("uuid"));
                    sender.send(reqMsg);
                    sender.setTimeToLive(10000);
                    session.commit();
                }else {
                    break;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    //关闭链接
    public void exit(){
        try{
            if(connection!=null){
                connection.close();
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }


    public static void main(String[] args) {
        QueueReceiver queueReceiver = new QueueReceiver();
        queueReceiver.receiveMsg();
        queueReceiver.exit();
    }
}



二、消息生产者（点对点）：

package senders;


import Constants.Constant;
import org.apache.activemq.ActiveMQConnection;
import org.apache.activemq.ActiveMQConnectionFactory;


import javax.jms.*;
import java.util.UUID;


/**
 * jms消息发送者，点对点
 * Created with IntelliJ IDEA.
 * User: wxshi
 * Date: 15-3-6
 * Time: 下午4:57
 * To change this template use File | Settings | File Templates.
 */
public class QueueSender {


    private ConnectionFactory connectionFactory;    // ConnectionFactory ：连接工厂，JMS 用它创建连接
    private Connection connection = null;   //Provider 的连接 Connection ：JMS 客户端到JMS
    private Session session;     // Session： 一个发送或接收消息的线程
    private Destination destination;   // Destination ：消息的目的地;消息发送给谁.
    private String uuid ;
    private Destination destinationReq;     //消息确认队列


    public QueueSender(){
        try{
           // 构造ConnectionFactory实例对象，此处采用ActiveMq的实现jar
            connectionFactory = new ActiveMQConnectionFactory(
                    ActiveMQConnection.DEFAULT_USER,
                    ActiveMQConnection.DEFAULT_PASSWORD, Constant.MQ_URL);
            connection = connectionFactory.createConnection();   // 获取操作连接
            session = connection.createSession(Boolean.TRUE,Session.AUTO_ACKNOWLEDGE); //创建jms会话
            destination = session.createQueue(Constant.QUEUE);    //创建消息队列，即消息目的地
            destinationReq = session.createQueue(Constant.RESPOMSE_QUEUE);
            connection.start(); // 启动
        }catch (Exception e){
            e.printStackTrace();
        }
    }


    //发送消息
    public void sendMessage(){
       try{
           MessageProducer producer = null;    // MessageProducer：消息发送者
           producer = session.createProducer(destination);       // 得到消息生成者【发送者】
           producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT);  // 设置不持久化，此处学习，实际根据项目决定
           producer.setTimeToLive(10000);    //设置消息十秒后失效
           for (int i = 1; i <= Constant.SEND_NUMBER; i++) {
               Message message = null;
               uuid = UUID.randomUUID().toString();
               if(i==1){
                   message = session.createTextMessage("ActiveMq 发送的消息"+ i);


                   //以下两行是设置消息选择器
                   message.setJMSCorrelationID("1");
                   message.setStringProperty("msgName", "消息1");
                   System.out.println("发送text消息：" + "ActiveMq 发送的消息" + i);
               }else if(i==2){
                   message = session.createStreamMessage();
                   message.setStringProperty("streamName","streamMsg消息名"+i);
                   message.setStringProperty("streamContent","streamMsg消息内容"+i);
                   //以下两行是设置消息选择器
                   message.setJMSCorrelationID("2");
                   message.setStringProperty("msgName", "消息2");
                   System.out.println("发送stream消息：" + "ActiveMq 发送的消息" + i);
               }else if(i==3){
                   message = session.createObjectMessage();
                   ((ObjectMessage)message).setObject(new String("object消息内容"+i));
                   //以下两行是设置消息选择器
                   message.setJMSCorrelationID("3");
                   message.setStringProperty("msgName", "消息3");
                   System.out.println("发送object消息：" + "ActiveMq 发送的消息" + i);
               }else if(i==4){
                   message = session.createObjectMessage();
                   ((ObjectMessage)message).setObject(new String("object消息内容"+i));
                   //以下两行是设置消息选择器
                   message.setJMSCorrelationID("4");
                   message.setStringProperty("msgName", "消息4");
                   System.out.println("发送object消息：" + "ActiveMq 发送的消息" + i);
               }else{
                   message = session.createMapMessage();
                   message.setStringProperty("mapName","map消息"+i);
                   message.setStringProperty("mapContent","map消息内容"+i);
                   //以下两行是设置消息选择器
                   message.setJMSCorrelationID("5");
                   message.setStringProperty("msgName", "消息5");
                   System.out.println("发送map消息：" + "ActiveMq 发送的消息" + i);
               }
               message.setJMSReplyTo(destinationReq);
               message.setStringProperty("uuid",uuid);
               producer.send(message);  // 发送消息到目的地方
               session.commit();
               this.receiveReq();
              // String filter = "JMSCorrelationID = '"+message.getJMSMessageID()+"'";
           }
          // session.commit();
       }catch (Exception e){
           e.printStackTrace();
       }
    }


    //接收确认消息
    public void receiveReq(){
        try{
            while(true){
                String filter = "JMSCorrelationID = '"+uuid+"'";      //收到接收者1的确认消息
                MessageConsumer consumer = session.createConsumer(destinationReq,filter);
                TextMessage message = (TextMessage) consumer.receive(10000);
                if(message!=null){
                    System.out.println("收到消息确认：" + message.getText());
                    System.out.println("------------------");
                } else{
                    break;
                }
            }
        }catch (JMSException e){
            e.printStackTrace();
        }
    }
    //关闭链接
    public void exit(){
        try{
            if(connection!=null){
                connection.close();
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }




    public static void main(String[] args) {
        QueueSender queueSender = new QueueSender();
        queueSender.sendMessage();
       // queueSender.receiveReq();
        queueSender.exit();
    }

}


三、消息接收者（订阅、发布）：

package recevers;


import Constants.Constant;
import org.apache.activemq.ActiveMQConnection;
import org.apache.activemq.ActiveMQConnectionFactory;


import javax.jms.*;


/**
 * 持久订阅者，在没有开启的情况下，也不会漏掉消息
 * Created with IntelliJ IDEA.
 * User: wxshi
 * Date: 15-3-9
 * Time: 下午4:05
 * To change this template use File | Settings | File Templates.
 */
public class TopicRecever {


    private ConnectionFactory connectionFactory; // ConnectionFactory ：连接工厂，JMS用它创建连接
    private Connection connection = null ;    // Connection ：JMS客户端到JMS Provider的连接
    private Session session; // Session：一个发送或接收消息的线程
    private Topic topic; //主题


    public TopicRecever(){
          try {
              connectionFactory = new ActiveMQConnectionFactory(
                      ActiveMQConnection.DEFAULT_USER,
                      ActiveMQConnection.DEFAULT_PASSWORD,
                      Constant.MQ_URL);
              connection =connectionFactory.createConnection();   // 构造从工厂得到连接对象
              connection.setClientID("clientID0019");
              connection.start();   // 启动
              session = connection.createSession( false ,Session.AUTO_ACKNOWLEDGE);      // 获取session
              topic = session.createTopic(Constant.TOPIC);  // 获取操作连接主题  ，消费者从这里获取消息
          }catch (JMSException e){
              e.printStackTrace();
          }
    }


    //接收消息并处理
    public void receiveMessage(){
        try {
            MessageConsumer consumer = null;     // 消费者，消息接收者
            String msgSelecter = "JMSCorrelationID='1' AND msgName='消息1'";   //定义消息选择器
            consumer = session.createDurableSubscriber(topic, "MQ_sub19",msgSelecter,false);    // 得到消息生成者【发送者】
            while ( true ){
                // 设置接收者接收消息的时间，为了便于测试，这里谁定为100s
                Message message = consumer.receive(100000);
                if (null != message) {
                    if(message instanceof TextMessage){
                        System.out.println("收到text消息：" + ((TextMessage) message).getText());
                        System.out.println("----------------------------");
                    }else if(message instanceof StreamMessage){
                        System.out.println("收到stream消息名：" + message.getStringProperty("streamName"));
                        System.out.println("收到stream消息内容：" + message.getStringProperty("streamContent"));
                        System.out.println("----------------------------");
                    }else if(message instanceof MapMessage){
                        System.out.println("收到map消息名：" + message.getStringProperty("mapName"));
                        System.out.println("收到map消息内容：" + message.getStringProperty("mapContent"));
                        System.out.println("----------------------------");
                    }else if(message instanceof ObjectMessage){
                        System.out.println("收到object消息：" + ((ObjectMessage) message).getObject().toString());
                        System.out.println("----------------------------");
                    }
                } else break ;
            }
        }catch (JMSException e){
            e.printStackTrace();
        }


    }


    //关闭链接
    public void exit(){
        try{
            if(connection!=null){
                connection.close();
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }


    public static void main(String[] args) {
        TopicRecever topicRecever = new TopicRecever();
        topicRecever.receiveMessage();
        topicRecever.exit();
    }
}




四、消息生产者（订阅、发布）：

package senders;


import Constants.Constant;
import org.apache.activemq.ActiveMQConnection;
import org.apache.activemq.ActiveMQConnectionFactory;


import javax.jms.*;


/**
 * jms消息服务：发布/订阅模式
 * Created with IntelliJ IDEA.
 * User: wxshi
 * Date: 15-3-9
 * Time: 下午4:04
 * To change this template use File | Settings | File Templates.
 */
public class TopicSender {


    private ConnectionFactory connectionFactory; // ConnectionFactory ：连接工厂，JMS用它创建连接
    private Connection connection = null ;    // Connection ：JMS客户端到JMS Provider的连接
    private Session session; // Session：一个发送或接收消息的线程
    private Topic topic; //主题


    public TopicSender(){
          try{
              connectionFactory = new ActiveMQConnectionFactory(
                      ActiveMQConnection.DEFAULT_USER,
                      ActiveMQConnection.DEFAULT_PASSWORD,
                      Constant.MQ_URL);
              connection = connectionFactory.createConnection();  //得到连接对象
              connection.start(); //启动
              //获取操作连接
              session = connection.createSession( false , Session.AUTO_ACKNOWLEDGE);
              topic = session.createTopic(Constant.TOPIC);    // 主题，消息目的地
          }catch (JMSException e){
              e.printStackTrace();
          }
    }


    //发送消息
    public void sendMessage(){
        try{
            MessageProducer producer = null;  //消息发送者
            producer = session.createProducer(topic);  // 得到消息生成者【发送者】
            producer.setDeliveryMode(DeliveryMode.PERSISTENT);  //设置持久化
            for ( int i= 1 ; i<=Constant.SEND_NUMBER; i++){
                Message message = null;
                if(i==1){
                    message = session.createTextMessage("ActiveMq 发送的消息"+ i);


                    //以下两行是设置消息选择器
                    message.setJMSCorrelationID("1");
                    message.setStringProperty("msgName", "消息1");
                    System.out.println("发送text消息：" + "ActiveMq 发送的消息" + i);
                }else if(i==2){
                    message = session.createStreamMessage();
                    message.setStringProperty("streamName","streamMsg消息名"+i);
                    message.setStringProperty("streamContent","streamMsg消息内容"+i);


                    //以下两行是设置消息选择器
                    message.setJMSCorrelationID("2");
                    message.setStringProperty("msgName", "消息2");
                    System.out.println("发送stream消息：" + "ActiveMq 发送的消息" + i);
                }else if(i==3){
                    message = session.createObjectMessage();
                    ((ObjectMessage)message).setObject(new String("object消息内容"+i));


                    //以下两行是设置消息选择器
                    message.setJMSCorrelationID("3");
                    message.setStringProperty("msgName", "消息3");
                    System.out.println("发送object消息：" + "ActiveMq 发送的消息" + i);
                }else{
                    message = session.createMapMessage();
                    message.setStringProperty("mapName","map消息"+i);
                    message.setStringProperty("mapContent","map消息内容"+i);


                    //以下两行是设置消息选择器
                    message.setJMSCorrelationID("4");
                    message.setStringProperty("msgName", "消息4");
                    System.out.println("发送map消息：" + "ActiveMq 发送的消息" + i);
                }
                producer.send(message);
            }
        }catch (JMSException e){
            e.printStackTrace();
        }
    }


    //关闭链接
    public void exit(){
        try{
            if(connection!=null){
                connection.close();
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }




    public static void main(String[] args) {
        TopicSender topicSender = new TopicSender();
        topicSender.sendMessage();
        topicSender.exit();
    }


}


wxshi_java
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ActiveMq 点对点模式、发布订阅模式、jms监听
qq_44261638的博客
01-10 409
详细介绍参见博客：https://www.cnblogs.com/yanfei1819/p/10615605.html 本文介绍springboot 中使用ActiveMq ，典例体现点对点模式、发布订阅模式 一：点对点模式 点对点模型，采用的是队列(Queue)作为消息载体。在该模式中，一条消息只能被一个消费者消费，没有被消费的，只能留在队列中，等待被消费，或者超时。举个例子，如果队列中有10...
JMS消息机制--发布-订阅模式
热门推荐
illusion_Luna的专栏
10-15 1万+
前面一张文章中我已经写过关于JMS消息机制的PTP（点对点）模式，今天我来写一下我个人对于JMS消息机制的发布-订阅模式。 在看是正文前，我想向大家阐述一下关于PTP与发布-订阅的特点和区别。 特点： 点对点消息模型：通过一个服务器消息队列实现，消息的发送者向队列写入消息，消息的接收者从队列取出消息。 发布-订阅模式：把消息发送到给一个主题(Topic)，消息服务器将消息发布给订阅器该主题
JMS之ActiveMQ 点对点+发布/订阅
07-05
JMS之ActiveMQ 点对点+发布/订阅
ActiveMQ--JMS的点对点模式于发布订阅模式的总结
sout
12-10 242
一、点对点模型（peer-to-peer） 点对点模型是基于队列的，生产者发送消息到队列，消费者从队列中接收消息，队列的存在使消息可以进行异步传输。 类似于用手机发短信，不必双方手机都开机。 1.在非事务状态下，当session关闭时如果有消息收到但还没有被签收（acknowledged），那当消费者下次连接到相同的队列时，这些消息还会被再次接收。 2.队列可以长久的保存消息直到消费者收到...
JMS--点对点、发布订阅
吴声子夜歌的博客
01-20 248
点对点 点对点模型是基于队列的，生产者发消息到队列，消费者从队列接收消息，队列的存在使得消息的异步传输成为可能。和我们平时给朋友发送短信类似。 如果在Session关闭时有部分消息已被收到但是还没有被签收（acknowledge），那当消费者下次连接到相同的队列时，这些消息还会被再次接收。 队列可以长久地保存消息直到消费者收到消息。消费者不需要因为担心消息会丢失而时刻和队列保持激活的连接状...
JMS中点对点消息
深入一点
08-07 262
    点对点消息传送模型允许JMS客户端通过队列(Queue)这个虚拟通道来同步和异步发送、接收消息。消息的生产者成为QueueSender，消费者为QueueReceiver。点对点模型是一个基于拉取(pull，即receive方式)或者基于轮询(polling,即异步接收)的消息传输模型，这种模型从队列中请求消息，而不是JMS Provider将消息自动的推送给客户端。发送到队列的任何一...
JMS的消息模式
清扬叶
07-13 606
中间件是指一类软件，是基于分布式处理的软件，最突出的特点是其网络通信功能。 消息中间件是指利用高效可靠的消息传递机制进行平台无关的数据交流，并基于数据通信来进行分布式系统的集成。通过提供消息传递和消息排队模型，它可以在分布式环境下扩展进程间的通信。 消息中间件可以即支持同步方式，又支持异步方式。异步中间件比同步中间件具有更强的容错性，在系统故障时可以保证消息的正常传输。异步中间
activeMq点对点和发布/订阅模式demo
06-27
在`activeMQ_demo`这个压缩包中，可能包含了一些示例代码，用于演示如何使用ActiveMQ实现点对点和发布/订阅模式。这些示例可能包括了以下内容： 1. 生产者（Producer）：创建和发送消息到队列或主题的代码，展示了...
apache MQ 点对点，发布/订阅者，开发流程
12-25
总结，Apache ActiveMQ提供了灵活的消息传递机制，支持点对点和发布/订阅模式，适用于各种分布式系统中的数据通信。通过理解并熟练掌握这两种模式的开发流程，开发者可以有效地构建和优化自己的应用程序。
Apache ActiveMQ学习笔记【原创：mq的方式有两种：点到点和发布/订阅】
05-07
### Apache ActiveMQ 学习笔记 ...点对点模型适用于一对一的消息传递场景，而发布/订阅模型则适用于一对多的消息分发场景。此外，通过示例代码，我们也了解了如何使用 Java 和 Spring 框架与 ActiveMQ 集成来发送消息。
JMs-----消息模型
无名小辈
09-29 294
一.p2p 点对点消息模型 1.消息队列 queue 2.发送者 sender 3.接受者 receiver 消息队列的模型为： 1.点对点模式 2.订阅模式 生产者 --------------消息队列---------------------------消费者 生产者 消费者 之间的消息存在三个概念 消息的持久化 ，将消息存入 数据库中 从...
JMS消息通信模式介绍
chitankong1289的博客
05-13 597
JMS消息通信模式介绍 1、Apollo的几种消息通信模式： Apollo是JMS消息通信规范的一个实现，使用activemq需要启动服务的主要过程。按照JMS的规范，我们首先需要获得一个JMS connectionfactory，通过这个connectionfactory来创建connect...
JMS_点对点消息传送模式
union
05-02 122
[color=blue]该实例通过由一个借方和一个抵押贷方组成的典型消息场景来讲述点对点模型[/color] [color=red]点对点模型最重要的特性如下：[/color] 1 消息通过称为队列的一个虚拟通道来进行交换.队列是生产者发送消息的目的地和接收者消费消息的消息源. 2 每条消息仅会传送给一个接收者.可能会有多个接受者在一个队列中侦听,但是每个队列中的消息只能被队列中的一个接...
JMS 发布/订阅消息 -- 同步
千里之行始于足下
06-24 918
– Start JMS 支持两种消息传递方式，一种是点对点方式(point-to-point (PTP))，一种是发布/订阅方式(publish/subscribe (pub/sub))。本文关注发布/订阅方式，先看看它的结构图。发布/订阅消息有以下特性。 1. Client1 是消息的发布者(Publisher)。 2. 消息被发送到一个主题(Topic)。 3. Client2 是消息的
JMS消息队列ActiveMQ(点对点模式)
weixin_34004750的博客
11-14 93
生产者(producer)->消息队列(message queue) 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48...
ActiveMQ知识盘点【壹】_JMS介绍及两种消息模式
xinzun的专栏
01-10 583
RabbitMQ知识盘点【壹】_消息队列介绍及三种消息路由模式 RabbitMQ知识盘点【贰】_实现原理及RabbitMQ集群 前两篇文章介绍了RabbitMQ，本文说一说ActiveMQ。 ActiveMQ是Apache软件基金下的一个开源软件。不同于RabbitMQ，它遵循的是JMS1.1规范（Java Message Service），是消息驱动中间件软件（
【JMS】JMS支持的模式讲解
qq_38377525的博客
05-06 505
【JMS】JMS支持的模式讲解
JMS点对点的消息发送(一)
不懂夜的黑
04-28 136
[code="java"]/** * 测试类 * @author Jan * */ public class Test { private ConnectionFactory cf = null;// 通过这个工厂类就可以得到一个与JMS提供者的连接，即Conection。 private Connection con = null;/...
消息重发机制
onlychengzhi的博客
01-16 796
占位
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值