消息队列RabbitMQ

最新推荐文章于 2022-07-25 10:33:35 发布
最新推荐文章于 2022-07-25 10:33:35 发布
阅读量219 收藏
点赞数
文章标签： rabbitmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45611051/article/details/108952955
版权

在这里插入图片描述
在这里插入图片描述

RabbitMQ基础知识

在这里插入图片描述
消息队列的特性：
1.业务无关
2.FIFO
3.容灾
4.性能

在这里插入图片描述

RabbitMQ的特点和核心概念

高级消息队列协议：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

RabbitMQ的安装和启动

在这里插入图片描述
在这里插入图片描述

1 Linux下安装RabbitMQ

官方安装指南：https://www.rabbitmq.com/install-rpm.html
安装erlang

配置源：

vim /etc/yum.repos.d/rabbitmq_erlang.repo

将如下配置复制到rabbitmq_erlang.repo中

[rabbitmq-erlang]
name=rabbitmq-erlang
baseurl=https://dl.bintray.com/rabbitmq-erlang/rpm/erlang/22/el/7
gpgcheck=1
gpgkey=https://dl.bintray.com/rabbitmq/Keys/rabbitmq-release-signing-key.asc
repo_gpgcheck=0
enabled=1

在这里插入图片描述

yum clean all

yum makecache

在这里插入图片描述

然后yum install erlang
要确认源是“rabbitmq_erlang”

在这里插入图片描述

如果你网络不好，也可以使用下载好的直接安装
yum install安装包上传到linux的完整路径名.

在这里插入图片描述
当输入erl -version，弹出版本说明已经安装好了，
输erl能进入erl的界面
在这里插入图片描述

安装RabbitMQ
在这里插入图片描述

我们将要安装的RabbitMQ的版本是3.8.2

导入密钥

rpm --import https://www.rabbitmq.com/rabbitmq-release-signing-key.asc

下载rpm安装包：

wget https://dl.bintray.com/rabbitmq/all/rabbitmq-server/3.8.2/rabbitmq-server-3.8.2-1.el7.noarch.rpm

如果速度比较慢，就用：

wget https://github.com/rabbitmq/rabbitmq-server/releases/download/v3.8.2/rabbitmq-server-3.8.2-1.el7.noarch.rpm

也可以自己下载安装包，然后进行上传

下载完成后，安装：

yum install rabbitmq-server-3.8.2-1.el7.noarch.rpm

在这里插入图片描述

如果出现解压错误，说明下载了多次，用ls -la看一下有几个文件，如果有多个安装包，要把多余的删掉，把正确的改名为rabbitmq-server-3.8.2-1.el7.noarch.rpm，再执行yum install来安装
到这里RabbitMQ就安装好了

RabbitMQ常用命令
r)

停止RabbitMQ

$rabbitmqctl stop

设置开机启动

$ systemctl enable rabbitmq-server

启动RabbitMQ

$ systemctl start rabbitmq-server

看看端口有没有起来，查看状态

$ rabbitmqctl status

在这里插入图片描述

要检查RabbitMQ服务器的状态，请运行：

systemctl status rabbitmq-server

在这里插入图片描述

开启web管理界面

rabbitmq-plugins enable rabbitmq_management

RabbitMQ的应用

RabbitMQ的管理后台

在这里插入图片描述
开启web管理界面

rabbitmq-plugins enable rabbitmq_management

在这里插入图片描述
添加用户账号：

添加用户名为admin，密码为123456的用户

 rabbitmqctl add_user admin 123456

在这里插入图片描述
给用户设置权限（把admin添加到administrator中【用户管理员】）

rabbitmqctl set_user_tags admin administrator

在这里插入图片描述
默认管理后台的端口为15672

之后便可以在浏览器中输入IP地址和端口号进入后台管理页面：
在这里插入图片描述
在这里插入图片描述

新建RabbitMQ项目：

先新建maven项目，然后引入两个依赖


<!--    rabbitMQ依赖-->
    <dependency>
        <groupId>com.rabbitmq</groupId>
        <artifactId>amqp-client</artifactId>
        <version>5.8.0</version>
    </dependency>
<!--    记录日志的依赖-->
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-nop</artifactId>
        <version>1.7.29</version>
    </dependency>

外界访问RabbitMQ用的是5672端口，因此需要先开启此端口
在后台管理的Permissions添加用户在这里插入图片描述

发送消息的步骤：
在这里插入图片描述
第一个生产者：

package helloWorld;


import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * Hello World 的发送消息类，连接到RabbitMQ服务端，然后发送消息，然后退出
 */
public class Send {
    private final static String QUEUE_NAME = "hello";

    public static void main(String[] args) throws IOException, TimeoutException {

        //创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();

        //设置RabbitMQ地址
        factory.setHost("192.168.91.130");
        factory.setUsername("admin");
        factory.setPassword("123456");

        //建立连接
        Connection connection = factory.newConnection();

        //获取信道
        Channel channel = connection.createChannel();

        //声明队列
        channel.queueDeclare(QUEUE_NAME, false, false, false,null);

        //发布消息
        String message = "Hello World";
        channel.basicPublish("", QUEUE_NAME, null, message.getBytes("UTF-8"));
        System.out.println("发送了消息" + message);
        //关闭连接
        channel.close();

        connection.close();


    }
}

第一个生产者：

package helloWorld;

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Recv {

    private final static String QUEUE_NAME = "hello";

    public static void main(java.lang.String[] args) throws IOException, TimeoutException {

        //创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();

        //设置RabbitMQ地址
        factory.setHost("192.168.91.130");
        factory.setUsername("admin");
        factory.setPassword("123456");

        //建立连接
        Connection connection = factory.newConnection();

        //获取信道
        Channel channel = connection.createChannel();

        //声明队列
        channel.queueDeclare(QUEUE_NAME, false, false, false,null);

//接收消息并消费
        channel.basicConsume(QUEUE_NAME,true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                                       AMQP.BasicProperties properties, byte[] body)
                    throws IOException {

                String message = new String(body, "UTF-8");
                System.out.println("收到消息" + message);
            }
        });



    }
}

多个消费者平均分配压力：
在这里插入图片描述
根据工作量的平均：

package workqueues;

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * 批量接收消息
 */
public class MoreNewRecv {


    private final static String TASK_QUEUE_NAME = "task";

    public static void main(String[] args) throws IOException, TimeoutException {

        //创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();

        //设置RabbitMQ地址
        factory.setHost("192.168.91.130");
        factory.setUsername("admin");
        factory.setPassword("123456");

        //建立连接
        Connection connection = factory.newConnection();
        //获取信道
        final Channel channel = connection.createChannel();

        //声明队列
        channel.queueDeclare(TASK_QUEUE_NAME, true, false, false, null);

        //改为不自动确认消息
        channel.basicQos(1);
        channel.basicConsume(TASK_QUEUE_NAME,false,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String message = new String(body, "UTF-8");
                System.out.println("收到了消息" + message);
               try {
                   doWord(message);
                }finally {
                   System.out.println("消息处理完成" +
                           "" +
                           "");
//处理完成后再确认消息
                   channel.basicAck(envelope.getDeliveryTag(), false);
               }

            }
        });


    }


    private static void doWord(String task) {
        char[] chars = task.toCharArray();
        for (char ch : chars) {
            if (ch == '.') {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    }

交换机类型

在这里插入图片描述
第四种基本不会用到在这里插入图片描述

fanout模式

在这里插入图片描述
生产者：

package fanout;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * 发送日志信息
 */
public class EmitLog {
    private static final String EXCHANGE_NAME = "logs";

    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.91.130");
        factory.setUsername("admin");
        factory.setPassword("123456");

        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.FANOUT);

        String message = "info:Hello World";

        channel.basicPublish(EXCHANGE_NAME, "", null, message.getBytes("UTF-8"));

        System.out.println("发送了消息" + message);
        channel.close();
        connection.close();

    }
}

消费者：

package fanout;

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * 接收日志消息
 */

public class ReceiveLogs {
    private static final String EXCHANGE_NAME = "logs";

    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.91.130");
        factory.setUsername("admin");
        factory.setPassword("123456");

        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();
        channel.exchangeDeclare(EXCHANGE_NAME,
                BuiltinExchangeType.FANOUT);

//创建一个非持久、自动删除的队列
        String queueName = channel.queueDeclare().getQueue();
        channel.queueBind(queueName, EXCHANGE_NAME, "");

        System.out.println("开始接收消息");

        Consumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String message = new String(body, "UTF-8");
                System.out.println(message);

            }
        };
        channel.basicConsume(queueName, true, consumer);

    }

}

direct模式

在这里插入图片描述
实例：在这里插入图片描述
一个生产者：

package direct;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * 发送日志信息
 */
public class EmitLogDirect {
    private static final String EXCHANGE_NAME = "DirectLogs";

    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.91.130");
        factory.setUsername("admin");
        factory.setPassword("123456");

        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);

        String message = "info:Hello World";

        channel.basicPublish(EXCHANGE_NAME, "info", null, message.getBytes("UTF-8"));

        System.out.println("发送了消息" + "等级为info，内容为："+message);





        message = "warning:Hello World";

        channel.basicPublish(EXCHANGE_NAME, "warning", null, message.getBytes("UTF-8"));

        System.out.println("发送了消息" + "等级为warning，内容为："+message);







         message = "err:Hello World";

        channel.basicPublish(EXCHANGE_NAME, "err", null, message.getBytes("UTF-8"));

        System.out.println("发送了消息" + "等级为err，内容为："+message);
        channel.close();
        connection.close();

    }
}

接收3种类型的消费者：

package direct;

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * 接收3个类型的日志
 */
public class ReceiveLogsDirect1 {



    private static final String EXCHANGE_NAME = "DirectLogs";

    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.91.130");
        factory.setUsername("admin");
        factory.setPassword("123456");

        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();
        channel.exchangeDeclare(EXCHANGE_NAME,
                BuiltinExchangeType.DIRECT);

//创建一个非持久、自动删除的队列

        //生成随机的、临时的queue
        String queueName = channel.queueDeclare().getQueue();

       //一个交换机绑定3个queue
        channel.queueBind(queueName, EXCHANGE_NAME, "info");
        channel.queueBind(queueName, EXCHANGE_NAME, "warning");
        channel.queueBind(queueName, EXCHANGE_NAME, "err");

        System.out.println("开始接收消息");

        Consumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String message = new String(body, "UTF-8");
                System.out.println(message);

            }
        };
        channel.basicConsume(queueName, true, consumer);

    }
}

只接收一种类型的接受者:

package direct;

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * 接收3个类型的日志
 */
public class ReceiveLogsDirect2 {



    private static final String EXCHANGE_NAME = "DirectLogs";

    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.91.130");
        factory.setUsername("admin");
        factory.setPassword("123456");

        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();
        channel.exchangeDeclare(EXCHANGE_NAME,
                BuiltinExchangeType.DIRECT);

//创建一个非持久、自动删除的队列

        //生成随机的、临时的queue
        String queueName = channel.queueDeclare().getQueue();

       //一个交换机绑定1个queue
     channel.queueBind(queueName, EXCHANGE_NAME, "err");

        System.out.println("开始接收消息");

        Consumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String message = new String(body, "UTF-8");
                System.out.println(message);

            }
        };
        channel.basicConsume(queueName, true, consumer);

    }
}

topic模式

在这里插入图片描述
在这里插入图片描述
生产者：

package topic;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * topic交换机，发送信息
 */
public class EmitLogTopic {
    private static final String EXCHANGE_NAME = "TopicLogs";

    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.91.130");
        factory.setUsername("admin");
        factory.setPassword("123456");

        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.TOPIC);

        String message = "Animal World";


        String[] routingKeys = new String[9];
        routingKeys[0] = "quick.orange.rabbit";
        routingKeys[1] = "lazy.orange.elephant";
        routingKeys[2] = "quick.orange.fox";
        routingKeys[3] = "lazy.brown.fox";
        routingKeys[4] = "lazy.pink.rabbit";
        routingKeys[5] = "quick.brown.fox";
        routingKeys[6] = "orange";
        routingKeys[7] = "quick.orange.male.rabbit";
        routingKeys[8] = "lazy.orange.male.rabbit";

        for (int i = 0; i < routingKeys.length; i++) {
            channel.basicPublish(EXCHANGE_NAME, routingKeys[i], null, message.getBytes("UTF-8"));
            System.out.println("发送了"+message+"  "+"routingKey"+routingKeys[i]);
        }


        channel.close();
        connection.close();

    }
}

消费者1：

package topic;

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * 特定路由键
 */
public class ReceiveLogsTopic1 {

    private static final String EXCHANGE_NAME = "TopicLogs";

    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.91.130");
        factory.setUsername("admin");
        factory.setPassword("123456");

        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();
        channel.exchangeDeclare(EXCHANGE_NAME,
                BuiltinExchangeType.TOPIC);

//创建一个非持久、自动删除的队列

        //生成随机的、临时的queue
        String queueName = channel.queueDeclare().getQueue();


        String routingKey = "*.orange.*";
        channel.queueBind(queueName, EXCHANGE_NAME, routingKey);



        System.out.println("开始接收消息");

        Consumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String message = new String(body, "UTF-8");
                System.out.println("收到消息" + message + "  " + "routingKey:" + envelope.getRoutingKey());

            }
        };
        channel.basicConsume(queueName, true, consumer);

    }
}

消费者2

package topic;

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * 特定路由键
 */
public class ReceiveLogsTopic2 {

    private static final String EXCHANGE_NAME = "TopicLogs";

    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.91.130");
        factory.setUsername("admin");
        factory.setPassword("123456");

        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();
        channel.exchangeDeclare(EXCHANGE_NAME,
                BuiltinExchangeType.TOPIC);

//创建一个非持久、自动删除的队列

        //生成随机的、临时的queue
        String queueName = channel.queueDeclare().getQueue();


        String routingKey = "*.*.rabbit";
        channel.queueBind(queueName, EXCHANGE_NAME, routingKey);

        String routingKey2 = "lazy.#";
        channel.queueBind(queueName, EXCHANGE_NAME, routingKey2);



        System.out.println("开始接收消息");

        Consumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String message = new String(body, "UTF-8");
                System.out.println("收到消息" + message + "  " + "routingKey:" + envelope.getRoutingKey());

            }
        };
        channel.basicConsume(queueName, true, consumer);

    }
}
半墓尘沙゜
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spring Boot集成RocketMq，向Vue端进行推送消息
知识改变命运，ヾ(◍°∇°◍)ﾉﾞ【求关注】
04-10 1406
最近使用rocketMq，通过生产消费消息，还要与前端实现实时同步消息的机制功能，因为我们这是SAAS系统所以需要按照单位进行消息区分，同单位的相关人员可以消费同一个消息。
SpringBoot整合RocketMQ-推送消息，拉取消息，延迟消息
weixin_43901631的博客
08-12 1417
SpringBoot整合RocketMQ-推送消息，拉取消息，延迟消息。
springboot+rabbitmq+vue实现stomp协议消息推送
被禁锢的玉
03-29 9263
springboot+rabbitmq+vue实现stomp协议消息推送rabbitmq添加stomp插件（具体操作就不描述了，自行百度）springboot添加maven依赖vue集成stompjs插件 rabbitmq添加stomp插件（具体操作就不描述了，自行百度） springboot添加maven依赖 <!-- amqp 默认RabbitMQ--> <...
springboot + RabbitMQ 使用stomp与前端VUE通讯
丶Melody
09-11 1962
maven <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency> application.yml spring: rabbitmq: host: 127.0.0.1 port: 5672 use
php stomp rabbitmq,rabbitmq stomp 安装配置 -- kkito的博客
weixin_29671137的博客
03-10 379
http://www.rabbitmq.com/http://www.rabbitmq.com/getstarted.htmlhttp://www.rabbitmq.com/download.html下载 Binary 包 #rabbitmq_server-2.8.5安装erlang #略去Erlang R14B03 (erts-5.8.4)sbin/rabbitmq-server #启动服务器....
高弹性低成本的云消息队列RabbitMQ版DEMO
最新发布
08-16
了解云消息队列RabbitMQ版和开源版本的区别和优势 云消息队列 RabbitMQ 版是一款基于高可用分布式存储架构实现的 AMQP 0-9-1 协议的消息产品，能够兼容开源 RabbitMQ 客户端。与开源 RabbitMQ 相比，能够解决各种...
消息队列RabbitMQ示例6种模式
01-22
简单模式：生产者与消费者 Work模式：发布者与3个订阅者 Topic交换机：生产者与3个消费者 Fanout交换机：生产者与2个消费者 Direct交换机：产生者与两个消费者 RPC远程回调：客户端与服务端
消息队列rabbitmq下载地址.rar
05-14
rabbitMQ是一个在AMQP协议标准基础上完整的，可服用的企业消息系统。它遵循Mozilla Public License开源协议，采用 Erlang 实现的工业级的消息队列(MQ)服务器，Rabbit MQ 是建立在Erlang OTP平台上。
Spring-rabbitMQ整合消息队列RabbitMQ
11-15
Spring boot整合消息队列RabbitMQ
消息队列RabbitMQ学习-1
01-20
RabbitMQ是一种广泛使用的开源消息队列服务器，它基于Advanced Message Queuing Protocol（AMQP）标准，旨在不同应用之间共享数据。由Erlang语言开发，RabbitMQ提供了跨平台的可移植性，支持多种编程语言，确保了...
SpringBoot+RabbitMQ+WebSocket
04-25
使用SpringBoot搭建的简单项目，通过RabbitMQ消息队列接收消息，使用WebSocket推送至前台页面；testWebSocket.html是用于接收的静态页面，直接用浏览器打开即可
基于 SpringBoot、Vue、Mybatis、RabbitMq、Mysql、Redis 等开发的轻量级的物联网综合业务平台
06-08
基于 SpringBoot、Vue、Mybatis、RabbitMq、Mysql、Redis 等开发的轻量级的物联网综合业务支撑平台。支持物联网卡、物联网模组、卡+模组融合管理。提供状态、资费、客户、进销存、合同、订单、续费、充值、诊断、账单等功能。平台可同时接入中国移动、中国电信、中国联通、第三方物联网卡进行统一管理。逐步完善平台，助您快速接入物联网，让万物互联更简单。
RocketMQ-Spring帮助开发者在SpringBoot中快速集成RocketMQ
08-07
帮助开发者在Spring Boot中快速集成RocketMQ。支持Spring Message规范，方便开发者从其它MQ快速切换到RocketMQ。
消息队列RabbitMQ研究与应用.pdf
04-12
rabbitmq 研究与应用.pdf
消息队列RabbitMQ入门与5种模式详解
01-27
RabbitMQ是开源的，实现了AMQP协议的，采用Erlang(面向并发编程语言)编写的，可复用的企业级消息系统； AMQP（高级消息队列协议）是一个异步消息传递所使用应用层协议规范，为面向消息中间件设计，基于此协议的...
SpringBoot+Netty+WebSocket 实现消息推送
芋艿V
07-25 270
点击上方“芋道源码”，选择“设为星标”管她前浪，还是后浪？能浪的浪，才是好浪！每天 10:33更新文章，每天掉亿点点头发...源码精品专栏原创 | Java 2021超神之路，很肝~中文详细注释的开源项目RPC 框架 Dubbo 源码解析网络应用框架 Netty 源码解析消息中间件 RocketMQ 源码解析数据库中间件 Sharding-JDBC 和 MyCAT ...
ActiveMQ的java操作
WOSHISUNXIANGFU的专栏
02-22 122
on; import javax.jms.MessageConsumer; import javax.jms.MessageProducer; import javax.jms.Session; import javax.jms.TextMessage; import org.apache.activemq.ActiveMQConnection; import org.apache.activemq.ActiveMQConnectionFactory; import org.apache.lo
5 SpringBoot整合RocketMQ发送同步消息
java1234的博客
09-01 1507
发送同步消息是指producer向 broker 发送消息，执行 API 时同步等待， 直到broker 服务器返回发送结果； 相对异步发送消息，同步会阻塞线程，性能相对差点，但是可靠性高，这种方式得到广泛使用，比如：短信通知，邮件通知，站内重要信息通知等。 RocketMQTemplate给我们提供了syncSend方法(有多个重载)，来实现发送同步消息； 下面给一个实例： /** * 发送同步消息 */ public void sendSyncMessage(){ for(int i=0;i&lt
实时推送消息(rabbitmq+vue实现stomp协议消息推送)
小Q的博客
08-30 8371
最近公司项目用到实时推送消息，所以把方法附上，各位有不同见解的留言。现在代码附上： index.html页面内引入js <script type="text/javascript" src="/static/sockjs.min.js" charset="utf-8"></script> <script type="text/javascript" src="/...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值