精华内容
下载资源
问答
  • IBMMQ监听消息队列
    2021-03-21 08:35:42

    **

    IBMMQ发送和接收消息示例:

    pom.xml下载jar包: com.ibm.mq

    com.ibm.mq.allclient

    9.1.0.0

    org.springframework

    spring-jms

    ${spring.version}

    public class MessageByMQ {

    // 定义队列管理器和队列的名称

    private static String qmName;

    private static String qName;

    private static MQQueueManager qMgr;

    public static void main(String args[]) {

    /* 下面两个方法可同时使用,也可以单独使用 */

    sendMessage("Hello Java MQ!");

    getMessage();

    }

    static {

    /**

    * 设置环境: MQEnvironment中包含控制MQQueueManager对象中的环境的构成的静态变量

    * MQEnvironment的值的设定会在MQQueueManager的构造函数加载的时候起作用

    * 因此必须在建立MQQueueManager对象之前设定MQEnvironment中的值.

    */

    MQEnvironment.hostname = "127.0.0.1"; // MQ服务器的IP地址

    MQEnvironment.channel = "OUT"; // 服务器连接的通道

    // 服务器MQ服务使用的编码1381代表GBK、1208代表UTF-8

    MQEnvironment.CCSID = 1208;

    MQEnvironment.port = 8080; // MQ 端口

    qmName = "DGE"; // MQ 的队列管理器名称

    qName = "abc"; // MQ 远程队列的名称

    try {

    // 定义并初始化队列管理器对象并连接

    // MQQueueManager 可以被多线程共享,但是从MQ 获取信息的时候是同步的,任何时候只有一个线程可以和MQ 通信。

    qMgr = new MQQueueManager(qmName);

    } catch (MQException e) {

    // TODO Auto-generated catch block

    System.out.println("初使化MQ出错");

    e.printStackTrace();

    }

    }

    /**

    * 往MQ发送消息

    *

    * @param message

    * @return

    */

    public static int sendMessage(String message) {

    int result = 0;

    try {

    // 设置将要连接的队列属性

    // 目标为远程队列,所有这里不可以用MQOO_INPUT_AS_Q_DEF属性

    // int openOptions = MQC.MQOO_INPUT_AS_Q_DEF | MQC.MQOO_OUTPUT;

    // 以下选项可适合远程队列与本地队列

    int openOptions = MQC.MQOO_OUTPUT | MQC.MQOO_FAIL_IF_QUIESCING;

    // 连接队列

    // MQQueue provides inquire, set, put and get operations for WebSphere MQ

    // queues.

    // The inquire and set capabilities are inherited from MQManagedObject.

    /* 关闭了就重新打开 */

    if (qMgr == null || !qMgr.isConnected()) {

    qMgr = new MQQueueManager(qmName);

    }

    MQQueue queue = qMgr.accessQueue(qName, openOptions);

    // 定义一个简单的消息

    MQMessage putMessage = new MQMessage();

    // 将数据放入消息缓冲区

    putMessage.writeUTF(message);

    // 设置写入消息的属性(默认属性)

    MQPutMessageOptions pmo = new MQPutMessageOptions();

    // 将消息写入队列

    queue.put(putMessage, pmo);

    queue.close();

    System.out.println("*******success*********");

    } catch (MQException ex) {

    System.out.println("A WebSphere MQ error occurred : Completion code " + ex.completionCode + " Reason code "

    + ex.reasonCode);

    ex.printStackTrace();

    } catch (IOException ex) {

    System.out.println("An error occurred whilst writing to the message buffer: " + ex);

    } catch (Exception ex) {

    ex.printStackTrace();

    } finally {

    try {

    qMgr.disconnect();

    } catch (MQException e) {

    e.printStackTrace();

    }

    }

    return result;

    }

    /**

    * 从队列中去获取消息,如果队列中没有消息,就会发生异常,不过没有关系,有TRY...CATCH,如果是第三方程序调用方法,如果无返回则说明无消息

    * 第三方可以将该方法放于一个无限循环的while(true){...}之中,不需要设置等待,因为在该方法内部在没有消息的时候会自动等待。

    *

    * @return

    */

    public static String getMessage() {

    String message = null;

    try {

    // 设置将要连接的队列属性

    int openOptions = MQC.MQOO_INPUT_AS_Q_DEF | MQC.MQOO_OUTPUT;

    MQMessage retrieve = new MQMessage();

    // 设置取出消息的属性(默认属性)

    // 设置放置消息选项

    MQGetMessageOptions gmo = new MQGetMessageOptions();

    gmo.options = gmo.options + MQC.MQGMO_SYNCPOINT;

    // 在同步点控制下获取消息

    gmo.options = gmo.options + MQC.MQGMO_WAIT;

    // 如果在队列上没有消息则等待

    gmo.options = gmo.options + MQC.MQGMO_FAIL_IF_QUIESCING;

    // 如果队列管理器停顿则失败

    gmo.waitInterval = 1000; // 设置等待的毫秒时间限制

    /* 关闭了就重新打开 */

    if (qMgr == null || !qMgr.isConnected()) {

    qMgr = new MQQueueManager(qmName);

    }

    MQQueue queue = qMgr.accessQueue(qName, openOptions);

    // 从队列中取出消息

    queue.get(retrieve, gmo);

    message = retrieve.readUTF();

    System.out.println("The message is: " + message);

    queue.close();

    } catch (MQException ex) {

    System.out.println("A WebSphere MQ error occurred : Completion code " + ex.completionCode + " Reason code "

    + ex.reasonCode);

    } catch (IOException ex) {

    System.out.println("An error occurred whilst writing to the message buffer: " + ex);

    } catch (Exception ex) {

    ex.printStackTrace();

    } finally {

    try {

    qMgr.disconnect();

    } catch (MQException e) {

    e.printStackTrace();

    }

    }

    return message;

    }

    }

    IBMMQ消息监听:

    pom.xml下载jms依赖jar包:

    org.springframework

    spring-jms

    ${spring.version}

    spring 配置文件:

    java代码:

    com.csdn.mq.SGMessageListener类:

    public abstract class SGMessageListener implements MessageListener {

    private static final Logger LOG = LoggerFactory.getLogger(SGMessageListener.class);

    private MessageConverter jmsConverter;

    public SGMessageListener() {

    }

    public void setJmsConverter(MessageConverter jmsConverter) {

    this.jmsConverter = jmsConverter;

    }

    public void onMessage(Message message) {

    try {

    //判断message中发送消息的类型,String还是byte[] ,根据类型进行转换

    byte[] fromMessage = (byte[]) jmsConverter.fromMessage(message);

    String xml = new String(fromMessage, "UTF-8");

    processMessage(xml);

    } catch (Throwable e) {

    LOG.error("Throwable {}", e.getMessage());

    }

    }

    public abstract void processMessage(String s);

    }

    com.csdn.mq.MQReceive类:

    public class MQReceive extends SGMessageListener{

    @Override

    public void processMessage(String msg)

    {

    System.out.println(msg);

    }

    }

    JMS只是一套规范和接口,IBM MQ是一种实现这个规范的产品,就像JDBC规范,每种数据库厂商会实现自己的JDBC JAR包,oracle的mysql的sqlserver的等等。

    更多相关内容
  • 对于ActiveMQ消息的发送,原声的api操作繁琐,而且如果不进行二次封装,打开关闭会话以及各种创建操作也是够够的了。那么,Spring提供了一个很方便的去收发消息的框架,spring jms。整合Spring后,代码不仅变得非常...

    对于ActiveMQ消息的发送,原声的api操作繁琐,而且如果不进行二次封装,打开关闭会话以及各种创建操作也是够够的了。那么,Spring提供了一个很方便的去收发消息的框架,spring jms。整合Spring后,代码不仅变得非常优雅,而且易用性和扩展性更好。

    废话不多说,直接开搞。

    1. maven依赖

    org.apache.xbean

    xbean-spring

    3.16

    org.springframework

    spring-jms

    ${springframework.version}

    org.apache.activemq

    activemq-all

    ${activemq.version}

    2.命名空间引入

    xmlns:jms="http://www.springframework.org/schema/jms"

    xsi:schemaLocation="http://www.springframework.org/schema/beans

    http://www.springframework.org/schema/beans/spring-beans-3.2.xsd

    http://www.springframework.org/schema/context

    http://www.springframework.org/schema/context/spring-context-3.2.xsd

    http://www.springframework.org/schema/jms

    http://www.springframework.org/schema/jms/spring-jms-4.1.xsd

    http://activemq.apache.org/schema/core

    http://activemq.apache.org/schema/core/activemq-core-5.8.0.xsd">

    3. Xml配置

    第一个是配置我们的mq连接,ip+端口号,帐号密码的信息。

    第二个是引入spring的mq连接池。可以配置缓存的连接数。

    第三个是消息处理器,Spring默认提供了基于Jdk Serializable的消息处理和MappingJackson2MessageConventer,其实这两个挺常用,在Spring Redis中,在Spring MVC中,都有着这几种conventer的身影。

    下面是两个发送消息的模版类,类似于之前讲过的RedisTemplate。向其注入上面定义的消息处理器,代码中我们会用到。(其实类中已经判断如果不进行注入就设置一个默认的,但是自己注入的话,方便我们控制)

    listener-container是Spring提供的一个监听器容器,用于统一控制我们的监听类来接收处理消息。这里面有一些配置,schema有说明。可以配置响应模式,消费者数量等。开启多消费者,有助于加快队列处理速度。

    4.注解方式的实现

    如果要用注解的方式,就不需要在xml中自己定义消息监听容器了。只需要加入以下的代码:

    这样,配置我们消费处理类上的@listener注解,即可监听对应的queue或者topic消息。

    5.生产者代码

    队列消息:

    @Resource

    @Component("queueSender")

    public class QueueSender {

    @Resource(name = "jmsQueueTemplate")

    private JmsTemplate jmsQueueTemplate;// 通过@Qualifier修饰符来注入对应的bean

    public void send(String destination, final Object message) {

    jmsQueueTemplate.send(destination, new MessageCreator() {

    @Override

    public Message createMessage(Session session) throws JMSException {

    return jmsQueueTemplate.getMessageConverter().toMessage(message, session);

    }

    });

    }

    }

    订阅消息:

    @Component

    public class TopicSender {

    @Resource(name="jmsTopicTemplate")

    private JmsTemplate jmsTemplate;

    /**

    * 发送一条消息到指定的队列(目标)

    * @param queueName 队列名称

    * @param message 消息内容

    */

    public void publish(String destination,final Object message){

    jmsTemplate.send(destination, new MessageCreator() {

    @Override

    public Message createMessage(Session session) throws JMSException {

    return jmsTemplate.getMessageConverter().toMessage(message, session);

    }

    });

    }

    }

    6.消费者代码

    package cn.test.activemq.consumer.queue;

    import javax.jms.JMSException;

    import javax.jms.Message;

    import javax.jms.Session;

    import org.slf4j.Logger;

    import org.slf4j.LoggerFactory;

    import org.springframework.jms.annotation.JmsListener;

    import org.springframework.jms.listener.adapter.MessageListenerAdapter;

    import org.springframework.jms.support.converter.MessageConversionException;

    import org.springframework.stereotype.Component;

    import cn.test.MqBean;

    import cn.test.activemq.message.types.QueueDefination;

    @Component("spqueueconsumertest")

    public class SpringQueueReciverTest extends MessageListenerAdapter{

    private static final Logger log = LoggerFactory.getLogger(SpringQueueReciverTest.class);

    @JmsListener(destination=QueueDefination.TEST_QUEUE,concurrency="5-10")

    public void onMessagehehe(Message message, Session session) throws JMSException {

    try {

    MqBean bean = (MqBean) getMessageConverter().fromMessage(message);

    System.out.println(bean.getName());

    System.out.println(session);

    message.acknowledge();

    message.acknowledge();

    } catch (MessageConversionException | JMSException e) {

    e.printStackTrace();

    }

    }

    }

    上面的@JmsListener(destination=QueueDefination.TEST_QUEUE,concurrency="5-10")是在用注解方式监听的时候加入。如果用xml配置容易,可以忽略。

    附上MqBean

    public class MqBean implements Serializable{

    private Integer age;

    private String name;

    public Integer getAge() {

    return age;

    }

    public void setAge(Integer age) {

    this.age = age;

    }

    public String getName() {

    return name;

    }

    public void setName(String name) {

    this.name = name;

    }

    }

    运行效果截图:

    0c2e402e1be61acb7e06cb071e28fc65.png

    ActiveMQ的基本用法大概就这些了。

    展开全文
  • ActiveMQ 结合 Spring 收发消息直接使用 ActiveMQ 的方式需要重复写很多代码,且不利于管理,Spring 提供了一种更加简便的方式————Spring JMS ,通过它可以更加方便地使用 ActiveMQ。Maven 依赖结合Spring使用...

    ActiveMQ 结合 Spring 收发消息

    直接使用 ActiveMQ 的方式需要重复写很多代码,且不利于管理,Spring 提供了一种更加简便的方式————Spring JMS ,通过它可以更加方便地使用 ActiveMQ。

    Maven 依赖

    结合Spring使用ActiveMQ的依赖如下:

    org.springframework

    spring-jms

    ${spring.version}

    org.apache.xbean

    xbean-spring

    3.16

    org.apache.activemq

    activemq-core

    5.7.0

    org.apache.activemq

    activemq-pool

    5.7.0

    ActiveMQ.xml 文件

    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

    xmlns:amq="http://activemq.apache.org/schema/core"

    xsi:schemaLocation="http://www.springframework.org/schema/beans

    http://www.springframework.org/schema/beans/spring-beans-4.0.xsd

    http://activemq.apache.org/schema/core

    http://activemq.apache.org/schema/core/activemq-core-5.12.1.xsd">

    brokerURL="tcp://localhost:61616"

    userName="admin"

    password="admin" />

    class="org.springframework.jms.listener.DefaultMessageListenerContainer">

    配置 connectionFactory

    connectionFactory 是 Spring 用于创建到 JMS 服务器链接的,Spring 提供了多种 connectionFactory。

    brokerURL="tcp://localhost:61616"

    userName="admin"

    password="admin" />

    配置Queue

    配置Topic

    配置JMS消息模板——jmsTemplate

    最后,在 applicationContext.xml 中引入配置好的 ActiveMQ.xml

    以上就是配置文件相关的,下面是具体的业务代码。

    消息生产者服务

    @Service

    public class ProducerService {

    @Autowired

    private JmsTemplate jmsTemplate;

    //使用默认目的地

    public void sendMessageDefault(final String msg){

    Destination destination = jmsTemplate.getDefaultDestination();

    System.out.println("向队列: " + destination + " 成功发送一条消息");

    jmsTemplate.send(new MessageCreator() {

    public Message createMessage(Session session) throws JMSException {

    return session.createTextMessage(msg);

    }

    });

    }

    //可指定目的地

    public void sendMessage(Destination destination,final String msg){

    jmsTemplate.send(destination, new MessageCreator() {

    public Message createMessage(Session session) throws JMSException {

    return session.createTextMessage(msg);

    }

    });

    }

    }

    消息消费者服务

    @Service

    public class ConsumerService {

    @Autowired

    private JmsTemplate jmsTemplate;

    //从指定的Destination接收消息

    public TextMessage recive(Destination destination){

    TextMessage message = (TextMessage) jmsTemplate.receive(destination);

    try {

    System.out.println("从队列" + destination.toString() + "收到了消息" + message.getText());

    } catch (JMSException e) {

    e.printStackTrace();

    }

    return message;

    }

    //从默认的Destination接收消息

    public void reciveDefault(){

    Destination destination = jmsTemplate.getDefaultDestination();

    jmsTemplate.setReceiveTimeout(5000);

    while(true){

    TextMessage message = (TextMessage) jmsTemplate.receive(destination);

    try {

    //这里还是同一个消费者

    System.out.println("消费者 从目的地 " + destination.toString() + " 收到了消息" + message.getText());

    } catch (JMSException e) {

    e.printStackTrace();

    }

    }

    }

    }

    生产者

    直接在 main 方法中获取 ApplicationContext 运行,便于测试。

    @Component

    public class MsgProducer {

    @Autowired

    private ProducerService producerService;

    public void send(){

    System.out.println("生产者开始发送消息:");

    for(int i = 1; i < 11; i++){

    String msg = "生产者发出的消息";

    producerService.sendMessageDefault(msg + "-----" + i);

    }

    }

    public static void main(String[] args) {

    ApplicationContext context = new ClassPathXmlApplicationContext("classpath:/applicationContext.xml");

    MsgProducer msgProducer = context.getBean(MsgProducer.class);

    msgProducer.send();

    }

    }

    消费者

    @Component

    public class MsgConsumer {

    @Autowired

    private ConsumerService consumerService;

    public void recive(){

    System.out.println("消费者 1 开始接收消息:");

    consumerService.reciveDefault();

    }

    public static void main(String[] args) {

    ApplicationContext context = new ClassPathXmlApplicationContext("classpath:/applicationContext.xml");

    MsgConsumer msgConsumer = context.getBean(MsgConsumer.class);

    msgConsumer.recive();

    }

    }

    接下来就可以启动项目。同样是使用两种方式测试。

    第一种方式————点对点(Queue)

    同步的方式

    先启动生产者发送10条消息, 再启动消费者,可以看到控制台显示成功收到10条消息。

    842c55f76b90bafc01479d4e65edcdcc.png

    842c55f76b90bafc01479d4e65edcdcc.png

    异步监听的方式

    通过监听器即可实现异步接收消息的效果,而不是像上面使用 while() 轮询同步的方式。

    项目中一般都是使用异步监听的方式,在 A 服务中发送了一条消息,B 服务可以利用消息监听器监听,当收到消息后,进行相应的操作。

    消息监听器(3种)

    通过继承 JMS 中的 MessageListener 接口,实现 onMessage() 方法,就可以自定义监听器。这是最基本的监听器。(可根据业务实现自定义的功能)

    另外spring也给我们提供了其他类型的消息监听器,比如 SessionAwareMessageListener,它的作用不仅可以接收消息,还可以发送一条消息通知对方表示自己收到了消息。(还有一种是 MessageListenerAdapter)

    一个简单的自定义监听器如下:收到消息后打印消息

    public class QueueMessageListener implements MessageListener {

    public void onMessage(Message message) {

    //如果有消息

    TextMessage tmessage = (TextMessage) message;

    try {

    if(tmessage != null){

    System.out.println("监听器监听消息:"+tmessage.getText());

    }

    } catch (JMSException e) {

    e.printStackTrace();

    }

    }

    }

    在 ActiveMQ.xml 中引入消息监听器:

    class="org.springframework.jms.listener.DefaultMessageListenerContainer">

    可以看到,当使用消息监听器之后,每发送一条消息立马就会被监听到:

    842c55f76b90bafc01479d4e65edcdcc.png

    第二种方式————发布/订阅(Topic)

    同步的方式

    类似点对点中同步的方式,只是每个消费者都能收到生产者发出的全部消息,不再赘述。

    异步监听的方式

    启动两个监听器(两个消费者),对消息进行异步监听。看是否各自能收到生产者发送的消息。

    842c55f76b90bafc01479d4e65edcdcc.png

    可以看到,每个监听器各自都收到了生产者发送的10条消息。

    以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持脚本之家。

    展开全文
  • 炭烧的朋友问我说,公司安排他让他研究一下如何在前端实现对RabbitMQ发送消息的实时监控,而这也涉及到了炭烧的知识盲区,于是炭烧就开始了学习的道路,接下来就跟着炭烧一起来学习一下这关于如何在前端监听到Rabb-...

    stomp协议即Simple (or Streaming) Text Orientated Messaging Protocol,简单(流)文本定向消息协议,它提供了一个可互操作的连接格式,允许STOMP客户端与任意STOMP消息代理(Broker)进行交互。

    最近一段时间,炭烧的朋友问我说,公司安排他让他研究一下如何在前端实现对RabbitMQ发送消息的实时监控,而这也涉及到了炭烧的知识盲区,于是炭烧就开始了学习的道路,接下来就跟着炭烧一起来学习一下这关于如何在前端监听到Rabb-=itMQ发送消息,以便实现自己项目中的功能吧。

    ##RabbitMQ支持的协议
    1.stomp协议

    stomp协议即Simple (or Streaming) Text Orientated Messaging Protocol,简单(流)文本定向消息协议,它提供了一个可互操作的连接格式,允许STOMP客户端与任意STOMP消息代理(Broker)进行交互。STOMP协议由于设计简单,易于开发客户端,因此在多种语言和多种平台上得到广泛地应用。

    而我们在接下来的文章里面主要讲stomp如何对RabbitMQ实现监听。

    stomp协议的前身是TTMP协议(一个简单的基于文本的协议),专为消息中间件设计。

    这句话就说出了,专门为了消息中间件设计的,其实他并不是针对RabbitMQ在前端使用的,而是针对整个消息中间件的使用。

    2.mqtt协议

    还有一种经常使用的,就是mqtt协议了,mqtt协议全称(Message Queuing Telemetry Transport,消息队列遥测传输协议),是一种基于发布/订阅(Publish/Subscribe)模式的轻量级通讯协议,该协议构建于TCP/IP协议上,由IBM在1999年发布,目前最新版本为v3.1.1。

    mqtt协议是属于在应用层协议的,这样也就是说只要是支持TCP/IP协议栈的地方,都可以使用mqtt.

    ##RabbitMQ开通stomp协议
    安装RabbitMQ的教程阿粉就不再给大家讲了,毕竟百度上有很多文章来告诉大家如何去安装RabbitMQ,不管是Linux还是Windows的,大家只要注意的一点就是,首先先安装erlang 语言支持,不然你安装RabbitMQ是安装不上的。

    开通Stomp协议:

    rabbitmq-plugins enable rabbitmq_web_stomp 
    rabbitmq-plugins enable rabbitmq_web_stomp_examples 
    #重启 
    service rabbitmq-server stop && service rabbitmq-server start 
    

    当我们开启之后,在我们的RabbitMQ中使能够看到的,如图:

    大家可以看到,我们正确开启之后,在RabbitMQ的控制台上,我们能够看到http/web-stomp 的端口是15674。

    接下来我们就要开始写一个案例进行测试。
    #前端Stomp监听RabbitMQ

    如果这个时候我们发送一条消息到消息队列,那么接下来他就会在页面上展示出我们需要的内容。

    我们看看代码是怎么写的吧。

    if (typeof WebSocket == 'undefined') { 
           console.log('不支持websocket') 
       } 
     
       // 初始化 ws 对象 
     
       var ws = new WebSocket('ws://localhost:15674/ws'); 
     
       // 获得Stomp client对象 
       var client = Stomp.over(ws); 
     
       // 定义连接成功回调函数 
       var on_connect = function(x) { 
           //data.body是接收到的数据 
           client.subscribe("/Fanout_Exchange/testMessage", function(data) { 
               var msg = data.body; 
               alert("收到数据:" + msg); 
           }); 
       }; 
     
       // 定义错误时回调函数 
       var on_error =  function() { 
           console.log('连接错误,请重试'); 
       }; 
     
       // 连接RabbitMQ 
       client.connect('guest', 'guest', on_connect, on_error, '/'); 
       console.log(">>>RabbitMQ已连接,测试正式开始"); 
    

    而这里面写的内容就比较有意思了,因为之前很多人都会发现,不管怎么写,都是不行,那是因为没有完全的理解,阿粉最后总结了一下关于Stomp的使用。

    #总结
    1./exchange/(exchangeName)

    对于 SUBCRIBE frame,destination 一般为/exchange/(exchangeName)/[/pattern] 的形式。该 destination 会创建一个唯一的、自动删除的、名为(exchangeName)的 queue,并根据 pattern 将该 queue 绑定到所给的 exchange,实现对该队列的消息订阅。
    对于 SEND frame,destination 一般为/exchange/(exchangeName)/[/routingKey] 的形式。这种情况下消息就会被发送到定义的 exchange 中,并且指定了 routingKey。
    2./queue/(queueName)

    对于 SUBCRIBE frame,destination 会定义(queueName)的共享 queue,并且实现对该队列的消息订阅。
    对于 SEND frame,destination 只会在第一次发送消息的时候会定义(queueName)的共享 queue。该消息会被发送到默认的 exchange 中,routingKey 即为(queueName)。
    3./amq/queue/(queueName)

    这种情况下无论是 SUBCRIBE frame 还是 SEND frame 都不会产生 queue。但如果该 queue 不存在,SUBCRIBE frame 会报错。
    对于 SUBCRIBE frame,destination 会实现对队列(queueName)的消息订阅。
    对于 SEND frame,消息会通过默认的 exhcange 直接被发送到队列(queueName)中。
    4./topic/(topicName)

    对于 SUBCRIBE frame,destination 创建出自动删除的、非持久的 queue 并根据 routingkey 为(topicName)绑定到 amq.topic exchange 上,同时实现对该 queue 的订阅。
    对于 SEND frame,消息会被发送到 amq.topic exchange 中,routingKey 为(topicName)。

    关于如何在前端监听RabbitMQ消息,你学会了么?
    #最后

    惊喜

    最后还准备了一套上面资料对应的面试题(有答案哦)和面试时的高频面试算法题(如果面试准备时间不够,那么集中把这些算法题做完即可,命中率高达85%+)

    image.png

    image.png

    ,命中率高达85%+)

    [外链图片转存中…(img-ZeyaQ2Aq-1623562146933)]

    [外链图片转存中…(img-dNKpStZ5-1623562146936)]

    资料获取方式:戳这里免费领取

    展开全文
  • 监听mq消息(用于监听DTO获取请求参数,结合spring配置) 【spring-rabbitmq.xml配置】:  &lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;beans xmlns="...
  • Spring 集成 IBM MQ 监听配置,包括用户管理配置和一些基础配置信息
  • 用三种方法实现从MQ队列接收消息java代码
  • 一、需求介绍后端使用spring boot2.0框架,要实现ibm mq的实时数据jms监听接收处理,并形成回执通过mq队列发送。二、引入依赖jar包org.springframeworkspring-jms4.3.18.releasejavax.jmsjavax.jms-api...
  • 最近soa项目要和官网系统对接,实现mq信息监听,保存等一些列操做。项目用的是Maven+SSM框架。而后学习和开发用了两天时间,算是搞定,趁加班时间作个总结。对于Maven工程的ssm框架,整合RabbitMq首先就是java1.引入...
  • Java下操作IBM Websphere MQ的项目案例, eclipse工程压缩包, 导入直接可用.
  • rabbitmq监听

    2018-10-16 23:40:15
    rabbitmq监听器测试程序,包括建立通道,测试舰艇通道等功能。
  • 项目使用springboot2.0.4搭建,一个父项目包含两个子项目:发送服务;监听服务;消息服务使用ActiveMQ 5.14.3,在docker中运行。 项目中有两种协议消息:activemq和mqtt。
  • MQ监听与接收数据JAVA

    2020-09-24 09:14:49
    import java.util.HashMap; import java.util.List; import java.util.Map; import javax.servlet.ServletContextEvent; import javax.servlet.ServletContextListener; import ...
  • 我需要编写一个监听WebSphere MQ服务器的Java客户机。消息放入服务器的队列中。Java客户端正在监听WebSphere MQ服务器?我开发了这个代码,但我不确定它是否正确。如果正确,那我该如何测试它?这是一个独立的Java...
  • 背景:消息队列中有非常多的消息需要处理,并且监听器onMessage()方法中的业务逻辑也相对比较复杂,为了加快队列消息的读取、处理速度。可以通过加快读取速度和加快处理速度来考虑。因此从这两个方面都使用多线程来...
  • 使用JAVA语言自己动手来写一个MQ (类似ActiveMQ,RabbitMQ) 主要角色首先我们必须需要搞明白MQ (消息队列)中的三个基本角色ProducerBrokerConsumer整体架构如下所示 自定义协议首先从上一篇中介绍了协议的相关信息,...
  • JMS调用IBM MQ监听模式

    2019-04-16 01:30:27
    NULL 博文链接:https://qiaokeli.iteye.com/blog/1782656
  • Springboot配置IBM MQ消息队列监听

    千次阅读 2019-11-07 09:28:26
    背景:服务端提供13个消息队列,做为客户端需要从队列中消费消息,刚开始使用死循环去消费,消费到一定量级后提示2044,扒了一下资料,发现可能是因为循环次数过多导致,然后开始研究队列监听方式来获取数据。...
  • 来自公众号:京东技术消息队列(MQ)是一种不同应用程序之间(跨进程)的通信方法。应用程序通过写入和检索出入列队的数据(消息)来通信,而无需通过专用链接来连接它们。消息传递指的是程序之间通过在消息中发送数据进行...
  • 一、配置mq参数:.yml文件或是相似config配置文件javatest:host:127.0.0.1port:1414username:testpassword:testchannel:TEST_CHANNEL //通道queue:TEST_QUEUE //队列名queue.manager:MANAGER //队列管理器ccsid:1381...
  • IBM MQ消息侦听器

    2021-07-17 00:31:50
    Hi does anyone know how to create a message listener using IBM MQ? I know how to do it using the JMS spec but I am not sure how to do it for IBM MQ. Any links or pointers are greatly appreciated.解决...
  • 理解JAVA MQ消息中间件

    千次阅读 2018-04-18 19:15:13
    MQ的几种消息传递方式发布订阅模式发布订阅模式有点类似于我们日常生活中订阅报纸。每年到年尾的时候,邮局就会发一本报纸集合让我们来选择订阅哪一个。在这个表里头列了所有出版发行的报纸,那么对于我们每一个订阅...
  • JAVA 调用MQ

    2021-02-26 10:32:54
    前提:MQ服务器端创建队列管理器:QueueManager队列:XML.IN服务器连接通道:SYSTEM.ADMIN.SVRCONN监听监听1414端口。package mq;import com.ibm.mq.MQC;import com.ibm.mq.MQEnvironment;import ...
  • Java中的Listener监听

    2020-12-22 23:51:59
     ServletContext监听  Session监听  Request监听  · Listener的应用实例  利用HttpSessionListener统计多在线用户人数  Spring使用ContextLoaderListener加载ApplicationContext配置信息  Spring使用...
  • 我们来学习如何将mqjava进行结合来实现功能。 1.简介1.1 什么是ActiveMQ ActiveMQ 是 Apache 出品,最流行的,能力强劲的开源消息总线。ActiveMQ 是一个 完全支持 JMS1.1 和 J2EE 1.4 规范的 JMS Provider 实现,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 24,086
精华内容 9,634
关键字:

java监听mq消息

java 订阅
友情链接: Simple_Calculator.rar