RabbitMQ

最新推荐文章于 2024-10-10 08:06:16 发布
最新推荐文章于 2024-10-10 08:06:16 发布
阅读量2.5k 收藏 23
点赞数 1
文章标签： rabbitmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Echouuu/article/details/104474408
版权

RabbitMQ

MQ全称为Message Queue，即消息队列. 它也是一个队列,遵循FIFO原则.
RabbitMQ官方地址：http://www.rabbitmq.com/
优点：
1.提高响应速度
2.服务异步调用
3.服务之间彻底解耦
3.消除峰值，把并发请求串行化执行
4.请求按顺序执行
6.数据不丢失，提高可用性
在这里插入图片描述

安装

  • 首先需要erlang语言的环境
    RabbitMQ的下载地址：http://www.rabbitmq.com/download.html
  • 配置环境变量
    在这里插入图片描述
    在这里插入图片描述

安装RabbitMQ

下载地址：https://github.com/rabbitmq/rabbitmq-server/releases/tag/v3.7.3
在sbin目录下cmd，安装rabbitMQ的管理插件，方便在浏览器端管理RabbitMQ;
rabbitmq-plugins.bat enable rabbitmq_management
安装插件后启动
在这里插入图片描述

登录

启动成功 登录RabbitMQ，进入浏览器，输入：http://localhost:15672
初始账号和密码：guest/guest
在这里插入图片描述

RabbitMQ–helloworld

1.RabbitMQ的使用

在这里插入图片描述

2.helloworld

在这里插入图片描述

2.1.导包
<dependency>
      <groupId>com.rabbitmq</groupId>
      <artifactId>amqp-client</artifactId>
      <!--和springboot2.0.5对应-->
      <version>5.4.1</version>
    </dependency>
2.2.工具类
public class ConnectionUtil {
    /**
     * 建立与RabbitMQ的连接
     * @return
     * @throws Exception
     */
    public static Connection getConnection() throws Exception {
        //定义连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        //设置服务地址
        factory.setHost("127.0.0.1");
        //端口
        factory.setPort(5672);
        //设置账号信息，用户名、密码、vhost
        factory.setVirtualHost("/");
        factory.setUsername("guest");
        factory.setPassword("guest");
        // 通过工程获取连接
        Connection connection = factory.newConnection();
        return connection;
    }
}
2.3.发送者
//消息发送者
public class Send {
    //队列名称
    public static final String QUEUE_NAME = "queue_name";

    public static void main(String[] args) throws Exception {
        //创建连接
        Connection connection = ConnectionUtil.getConnection();
        //创建通道
        Channel channel = connection.createChannel();
        //声明队列  队列名称、是否持久化、队列是否独占此连接、队列不再使用时是否自动删除此队列、队列参数
        channel.queueDeclare(QUEUE_NAME, true, false,false,null);
        //发送消息
        String msg = "canola";
        channel.basicPublish("", QUEUE_NAME, null, msg.getBytes());
        System.out.println("发送成功"+msg);

    }
}
2.4.接收端
//消息接受者
public class Rev {
    public static void main(String[] args) throws Exception {
        //创建连接
        Connection connection = ConnectionUtil.getConnection();
        //创建通道
        final Channel channel = connection.createChannel();
        //声明队列  队列名称、是否持久化、队列是否独占此连接、队列不再使用时是否自动删除此队列、队列参数
        channel.queueDeclare(Send.QUEUE_NAME, true, false, false, null);

        //回调方法
        DefaultConsumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //int i=1/0;
                System.out.println("接收"+new String(body));
                //设置手动签收 发生异常不会丢失数据 异常处理完毕再签收
                channel.basicAck(envelope.getDeliveryTag(),false );
            }
        };

        //自动签收如果发送异常，会造成数据丢失，而手动签收可以解决数据丢失的问题
        //接收消息 true自动签收 false手动签收
        channel.basicConsume(Send.QUEUE_NAME, false,consumer );
    }
}

RabbitMq-workqueues

work queues与入门程序相比，多了一个消费端，两个消费端共同消费同一个队列中的消息。

应用场景：对于任务过重或任务较多情况使用工作队列可以提高任务处理的速度。

在这里插入图片描述

1.发送者
//消息发送者
public class Send {
    //队列名称
    public static final String WORK_QUEUE_NAME = "work_queue_name";

    public static void main(String[] args) throws Exception {
        //创建连接
        Connection connection = ConnectionUtil.getConnection();
        //创建通道
        Channel channel = connection.createChannel();
        //声明队列  队列名称、是否持久化、队列是否独占此连接、队列不再使用时是否自动删除此队列、队列参数
        channel.queueDeclare(WORK_QUEUE_NAME, true, false,false,null);
        //发送消息
        String msg = "canola";
        channel.basicPublish("", WORK_QUEUE_NAME, null, msg.getBytes());
        System.out.println("发送成功"+msg);

    }
}
2.接受者–2

需要设置每个接收者消费消息的个数，不然出现异常就会导致这个接受者接收消息堵塞
channel.basicQos(1);

//消息接受者
public class Rev2 {
    public static void main(String[] args) throws Exception {
        //创建连接
        Connection connection = ConnectionUtil.getConnection();

        //创建通道
        final Channel channel = connection.createChannel();

        //声明队列  队列名称、是否持久化、队列是否独占此连接、队列不再使用时是否自动删除此队列、队列参数
        channel.queueDeclare(Send.WORK_QUEUE_NAME, true, false, false, null);

        //同时只能处理一个消息 不设置的话，一个消费者异常，导致不能接收消息，出现消息堵塞
        channel.basicQos(1);

        //回调方法
        DefaultConsumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {

                try {//模拟异常
                    Thread.sleep(10000000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //int i=1/0;
                System.out.println("接收"+new String(body));
                //设置手动签收 发生异常不会丢失数据 异常处理完毕再签收
                channel.basicAck(envelope.getDeliveryTag(),false );
            }
        };

        //自动签收如果发送异常，会造成数据丢失，而手动签收可以解决数据丢失的问题
        //接收消息 true自动签收 false手动签收
        channel.basicConsume(Send.WORK_QUEUE_NAME, false,consumer );
    }
}
3.接受者–2
//消息接受者
public class Rev2 {
    public static void main(String[] args) throws Exception {
        //创建连接
        Connection connection = ConnectionUtil.getConnection();

        //创建通道
        final Channel channel = connection.createChannel();

        //声明队列  队列名称、是否持久化、队列是否独占此连接、队列不再使用时是否自动删除此队列、队列参数
        channel.queueDeclare(Send.WORK_QUEUE_NAME, true, false, false, null);

        //同时只能处理一个消息 不设置的话，一个消费者异常，导致不能接收消息，出现消息堵塞
        channel.basicQos(1);

        //回调方法
        DefaultConsumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {

                try {//模拟异常
                    Thread.sleep(10000000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //int i=1/0;
                System.out.println("接收"+new String(body));
                //设置手动签收 发生异常不会丢失数据 异常处理完毕再签收
                channel.basicAck(envelope.getDeliveryTag(),false );
            }
        };

        //自动签收如果发送异常，会造成数据丢失，而手动签收可以解决数据丢失的问题
        //接收消息 true自动签收 false手动签收
        channel.basicConsume(Send.WORK_QUEUE_NAME, false,consumer );
    }
}

发布订阅模型

在这里插入图片描述
1、1个生产者，多个消费者

2、每一个消费者都有自己的一个队列

3、生产者没有将消息直接发送到队列，而是发送到了交换机

4、每个队列都要绑定到交换机

5、生产者发送的消息，经过交换机到达队列，实现一个消息被多个消费者获取的目的

交换机–Exchange
  • 交换机一方面：接收生产者发送的消息。另一方面：知道如何处理消息，例如递交给某个特别队列、递交给所有队列、或是将消息丢弃。到底如何操作，取决于Exchange的类型。
  • Exchange（交换机）只负责转发消息，不具备存储消息的能力，因此如果没有任何队列与Exchange绑定，或者没有符合路由规则的队列，那么消息会丢失！
  • 交换机分类

1.Fanout：广播
将消息交给所有绑定到交换机的队列 all

2.Direct：定向

把消息交给符合指定routing key 的队列 一堆或一个

3.Topic：通配符

把消息交给符合routing pattern（路由模式）的队列 一堆或者一个

1.广播模式

在这里插入图片描述
在广播模式下，消息发送流程：

  • 1） 可以有多个消费者
  • 2） 每个消费者有自己的queue（队列）
  • 3） 每个队列都要绑定到Exchange（交换机）
  • 4） 生产者发送的消息，只能发送到交换机，交换机来决定要发给哪个队列，生产者无法决定。
  • 5） 交换机把消息发送给绑定过的所有队列
  • 6） 队列的消费者都能拿到消息。实现一条消息被多个消费者消费
1.1.发送者

发送者需要声明交换机 ，不需要声明队列，发送消息的时候需要指定交换机，不需要指定routingkey；

//消息发送者
public class Send {
    //交换机名称
    public static final String EXCHANGE_NAME_FANOUT = "exchange_name_fanout";

    public static void main(String[] args) throws Exception {
        //创建连接
        Connection connection = ConnectionUtil.getConnection();
        //创建通道
        Channel channel = connection.createChannel();
        //声明交换机 指定消息发送模式为广播模式
        channel.exchangeDeclare(EXCHANGE_NAME_FANOUT, BuiltinExchangeType.FANOUT );
        //发送消息
        String msg = "canola";
        //指定交换机，不需要指定路由
        channel.basicPublish(EXCHANGE_NAME_FANOUT, "", null, msg.getBytes());
        System.out.println("发送成功"+msg);

    }
}
1.2.接受者-1
接受者需要声明队列 ， 需要给队列绑定交换机 ，接受者的交换机和消息发送者的交换机要一致。多个消息接受者，声明的队列的名字需要不一样，而交换机的名字需要一样。
//消息接受者
public class Rev {

    //队列名称
    public static final String QUEUE_NAME_FANOUT = "queue_name_fanout";

    public static void main(String[] args) throws Exception {

        //创建连接
        Connection connection = ConnectionUtil.getConnection();

        //创建通道
        final Channel channel = connection.createChannel();

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

        //绑定交换机  对列名字 交换机
        channel.queueBind(QUEUE_NAME_FANOUT, Send.EXCHANGE_NAME_FANOUT, "");

        //同时处理一个消息 不设置的话，一个消费者异常，导致不能接收消息，出现消息堵塞
        channel.basicQos(1);
        //回调方法
        DefaultConsumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //int i=1/0;
                System.out.println("接收"+new String(body));
                //设置手动签收 发生异常不会丢失数据 异常处理完毕再签收
                channel.basicAck(envelope.getDeliveryTag(),false );
            }
        };

        //自动签收如果发送异常，会造成数据丢失，而手动签收可以解决数据丢失的问题
        //接收消息 true自动签收 false手动签收
        channel.basicConsume(QUEUE_NAME_FANOUT, false,consumer );
    }
}
1.3.接受者-2
//消息接受者
public class Rev2 {

    //对列名称
    public static final String QUEUE_NAME_FANOUT_2 = "queue_name_fanout_2";
    public static void main(String[] args) throws Exception {
        //创建连接
        Connection connection = ConnectionUtil.getConnection();

        //创建通道
        final Channel channel = connection.createChannel();

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

        //绑定交换机
        channel.queueBind(QUEUE_NAME_FANOUT_2, Send.EXCHANGE_NAME_FANOUT,"" );

        //同时处理一个消息 不设置的话，一个消费者异常，导致不能接收消息，出现消息堵塞
        channel.basicQos(1);

        //回调方法
        DefaultConsumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {

                //int i=1/0;
                System.out.println("接收"+new String(body));
                //设置手动签收 发生异常不会丢失数据 异常处理完毕再签收
                channel.basicAck(envelope.getDeliveryTag(),false );
            }
        };

        //自动签收如果发送异常，会造成数据丢失，而手动签收可以解决数据丢失的问题
        //接收消息 true自动签收 false手动签收
        channel.basicConsume(QUEUE_NAME_FANOUT_2, false,consumer );
    }
}

2.定向模式

direct定向模式是交换机根据生产者指定的routingkey，收到消息后去匹配指定routingkey的队列，将消息发送给队列，消费者进行消费
在这里插入图片描述
P：生产者，向Exchange发送消息，发送消息时，会指定一个routing key。

X：Exchange（交换机），接收生产者的消息，然后把消息递交给 与routing key完全匹配的队列

C1：消费者，其所在队列指定了需要routing key 为 error 的消息

C2：消费者，其所在队列指定了需要routing key 为 info、error、warning 的消息

2.1.发送者
//消息发送者
public class Send {
    //交换机名称
    public static final String EXCHANGE_NAME_DIRECT = "exchange_name_direct";

    public static void main(String[] args) throws Exception {
        //创建连接
        Connection connection = ConnectionUtil.getConnection();
        //创建通道
        Channel channel = connection.createChannel();
        //声明交换机 指定消息发送模式为 定向模式
        channel.exchangeDeclare(EXCHANGE_NAME_DIRECT, BuiltinExchangeType.DIRECT );
        //发送消息
        String msg = "canola";
        //指定交换机，指定路由 会去匹配和routingkey相同的消费者消费
        channel.basicPublish(EXCHANGE_NAME_DIRECT, "info", null, msg.getBytes());
        System.out.println("发送成功"+msg);

    }
}
2.2.接受者
  • 和发送者的routingkey匹配上就会进行消费
  • 多个消息接收者，只需要声明不同的队列即可 ， 交换机是相同的 ，并且绑定队列的时候要指定队列的routingkey
//消息接受者
public class Rev2 {

    //对列名称
    public static final String QUEUE_NAME_DIRECT_2 = "queue_name_direct_2";
    public static void main(String[] args) throws Exception {
        //创建连接
        Connection connection = ConnectionUtil.getConnection();

        //创建通道
        final Channel channel = connection.createChannel();

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

        //绑定交换机 可以指定多个
        channel.queueBind(QUEUE_NAME_DIRECT_2, Send.EXCHANGE_NAME_DIRECT,"info" );
        channel.queueBind(QUEUE_NAME_DIRECT_2, Send.EXCHANGE_NAME_DIRECT,"warning" );

        //同时处理一个消息 不设置的话，一个消费者异常，导致不能接收消息，出现消息堵塞
        channel.basicQos(1);

        //回调方法
        DefaultConsumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {

                //int i=1/0;
                System.out.println("接收"+new String(body));
                //设置手动签收 发生异常不会丢失数据 异常处理完毕再签收
                channel.basicAck(envelope.getDeliveryTag(),false );
            }
        };

        //自动签收如果发送异常，会造成数据丢失，而手动签收可以解决数据丢失的问题
        //接收消息 true自动签收 false手动签收
        channel.basicConsume(QUEUE_NAME_DIRECT_2, false,consumer );
    }
}

通配符

topic的工作模式跟 direct是一样的 ， direct定向模式是交换机根据product指定的routingkey，收到消息后去匹配指定routingkey的队列，将消息发送给队列，消费者进行消费 ， 只是不一样的是，消费者在绑定队列的时候队列的routingkey可以使用通配符
#匹配多个
*匹配一个
在这里插入图片描述

3.1.发送者
//消息发送者
public class Send {
    //交换机名称
    public static final String EXCHANGE_NAME_TOPIC = "exchange_name_topic";

    public static void main(String[] args) throws Exception {
        //创建连接
        Connection connection = ConnectionUtil.getConnection();
        //创建通道
        Channel channel = connection.createChannel();
        //声明交换机 指定消息发送模式为 定向模式
        channel.exchangeDeclare(EXCHANGE_NAME_TOPIC, BuiltinExchangeType.TOPIC );
        //发送消息
        String msg = "canola";
        //指定交换机，指定路由 会去匹配和routingkey相同的消费者消费
        channel.basicPublish(EXCHANGE_NAME_TOPIC, "user.info", null, msg.getBytes());
        System.out.println("发送成功"+msg);

    }
}
3.2.接受者
//消息接受者
public class Rev {

    //队列名称
    public static final String QUEUE_NAME_TOPIC = "queue_name_topic";

    public static void main(String[] args) throws Exception {

        //创建连接
        Connection connection = ConnectionUtil.getConnection();

        //创建通道
        final Channel channel = connection.createChannel();

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

        //绑定交换机  对列名字 交换机 使用*通配符 匹配所以前缀为user的发送者
        channel.queueBind(QUEUE_NAME_TOPIC, Send.EXCHANGE_NAME_TOPIC, "user.*");

        //同时处理一个消息 不设置的话，一个消费者异常，导致不能接收消息，出现消息堵塞
        channel.basicQos(1);
        //回调方法
        DefaultConsumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //int i=1/0;
                System.out.println("接收"+new String(body));
                //设置手动签收 发生异常不会丢失数据 异常处理完毕再签收
                channel.basicAck(envelope.getDeliveryTag(),false );
            }
        };

        //自动签收如果发送异常，会造成数据丢失，而手动签收可以解决数据丢失的问题
        //接收消息 true自动签收 false手动签收
        channel.basicConsume(QUEUE_NAME_TOPIC, false,consumer );
    }
}

持久化–解决数据安全

要将消息持久化，队列、Exchange都要持久化；即使RabbitMQ关闭，数据也不会丢失；

1.发送端

发送端只需在声明交换机和发送消息的时候设置持久化
在这里插入图片描述

2.接收端

接收端只需将队列持久化
在这里插入图片描述

SpringBoot集成RabbitMQ

1.导包
 <!--1.SpringBoot的父工程-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.5.RELEASE</version>
    </parent>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-test</artifactId>
    </dependency>

    <!--spirngboot集成rabbitmq-->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-amqp</artifactId>
    </dependency>
  </dependencies>

  <dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-dependencies</artifactId>
        <version>2.0.5.RELEASE</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>
    </dependencies>
2.启动类
//启动类
@SpringBootApplication
public class RabbitMQApplication {
    public static void main(String[] args) {
        SpringApplication.run(RabbitMQApplication.class);
    }
}
3.配置类
@Component
public class RabbitmqConfig {
    //邮箱队列名
    public static final String QUEUE_INFORM_EMAIL = "queue_inform_email";
    //短信队列名
    public static final String QUEUE_INFORM_SMS = "queue_inform_sms";
    //交换机名字
    public static final String EXCHANGE_TOPICS_INFORM = "exchange_topics_inform";


    //定义交换机
    @Bean(EXCHANGE_TOPICS_INFORM)
    public Exchange exchangeTopic() {
        //durable(true)持久化，消息队列重启后交换机仍然存在
        return ExchangeBuilder.topicExchange(EXCHANGE_TOPICS_INFORM).durable(true).build();
    }
    /*******************************************************************/
    //声明邮箱队列
    @Bean(QUEUE_INFORM_EMAIL)
    public Queue queueEmail() {
        Queue queue = new Queue(QUEUE_INFORM_EMAIL);
        return queue;
    }

    //绑定邮箱队列到交换机,@Qualifier指定对应的队列或者交换机
    @Bean
    public Binding BINDING_QUEUE_INFORM_EMAIL(@Qualifier(QUEUE_INFORM_EMAIL) Queue queue,
                                              @Qualifier(EXCHANGE_TOPICS_INFORM) Exchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with("email.#").noargs();
    }


    /*******************************************************************/
    //声明短信队列
    @Bean(QUEUE_INFORM_SMS)
    public Queue queueSMS() {
        Queue queue = new Queue(QUEUE_INFORM_SMS);
        return queue;
    }

    //绑定短信到交换机
    @Bean
    public Binding BINDING_QUEUE_INFORM_SMS(@Qualifier(QUEUE_INFORM_SMS) Queue queue,
                                            @Qualifier(EXCHANGE_TOPICS_INFORM) Exchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with("sms.#").noargs();
    }
}
4.发送端
//发送端
@RunWith(SpringRunner.class)
@SpringBootTest(classes = RabbitMQApplication.class)
public class Send {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void test()throws Exception{

        for (int i=0;i<10;i++) {
            if (i % 2 == 0) {
                String EmailMsg = "邮箱";
                //交换机名称、路由的前缀以及消息
                rabbitTemplate.convertAndSend(RabbitmqConfig.EXCHANGE_TOPICS_INFORM, "email.user", EmailMsg);
            }else {
                String SMSMsg = "短信";
                rabbitTemplate.convertAndSend(RabbitmqConfig.EXCHANGE_TOPICS_INFORM, "sms.user", SMSMsg);
            }
        }

        Thread.sleep(10000);

    }
}
5.接收端
//接收端
@Component
public class Rev {
    //监听email队列  queues可以监听多个队列
    @RabbitListener(queues = {RabbitmqConfig.QUEUE_INFORM_EMAIL})
    public void receive_email(String msg, Message message, Channel channel) {
        System.out.println(msg);
    }

    //监听sms队列
    @RabbitListener(queues = {RabbitmqConfig.QUEUE_INFORM_SMS})
    public void receive_sms(String msg, Message message, Channel channel) {
        System.out.println(msg);
    }
}
大份土豆加凉面
关注
RabbitMQ入门
qq_43619628的博客
01-27 2460
mq
Rabbit MQ 学习
undefined
03-31 1322
Rabbit MQ 官网：https://www.rabbitmq.com/ 首先下载windows版本的Rabbit MQ Server 安装程序 打开网址https://www.rabbitmq.com/install-windows.html rabbitmq-server-3.18.14.exe
RabbitMQ HTTP认证与授权插件使用教程
最新发布
gitblog_00913的博客
10-10 461
RabbitMQ HTTP认证与授权插件使用教程 rabbitmq-auth-backend-http HTTP-based authorisation and authentication for RabbitMQ 项目地址: ...
RabbitMq官网地址和学习博客
weixin_41987908的博客
03-23 4042
https://www.rabbitmq.com/documentation.html
CentOS 安装rabbitmq之后,无法访问rabbitmq的管理端网页
festone000的专栏
08-07 3081
在CentOS7.4，使用rpm文件直接安装了erlang和rabbitmq，很顺利没有什么提示几下就成功了。 然后systemctl start rabbitmq-server，看了看端口很轻易就启动成功了。 但是15276的管理端网页却无法打开，浏览器访问时提示拒绝访问。 不知道时什么原因，随便查了查，看到几行可能有用的提示，搜了搜。找到了办法。 问题描述如图1. 接近方法如图2绿线部分(其他某些垃圾命令可忽略)： 处理后如图3，正常。 参考地址: TCP connection succeeded
RabbitMQ Server3.13.0
04-02
**RabbitMQ Server 3.13.0** RabbitMQ 是一个开源的消息代理和队列服务器，它基于AMQP（Advanced Message Queuing Protocol）协议，用于在分布式系统中高效地路由和传递消息。RabbitMQ 3.13.0 版本是其稳定版本之一...
rabbitMQrabbitMQ
08-01
rabbitMQrabbitMQ
rabbitmqrabbitmqrabbitmqrabbitmqrabbitmqrabbitmq
07-10
rabbitmqrabbitmqrabbitmqrabbitmqrabbitmqrabbitmq
rabbitmqadmin
07-08
RabbitMQ命令行手动创建队列rabbitmqadmin用法 手动创建队列方法：登录http://ip:15672/cli下载 将下载的rabbitmqadmin放到/usr/sbin目录下，并赋予权限：chmod 755 rabbitmqadmin 查看命令帮助信息： python ...
RabbitMQ镜像文件
02-27
RabbitMQ镜像文件
rabbitmq开发规范
07-04
**RabbitMQ开发规范详解** 在使用RabbitMQ进行分布式消息传输时，遵循一定的开发规范至关重要，这不仅可以提高系统的可维护性，也有助于保证数据的一致性和稳定性。本篇文章将详细阐述RabbitMQ的命名规范、消息传输...
rabbitmq3.10.4
06-07
RabbitMQ是一个开源的消息代理和队列服务器，广泛应用于分布式系统中的消息传递。它基于AMQP（Advanced Message Queuing Protocol）协议，为多种编程语言提供API，使得开发人员能够轻松地实现消息的发送和接收。在...
rabbitmq安装包
09-22
**RabbitMQ基础介绍** RabbitMQ是一款广泛应用的消息中间件，基于AMQP（Advanced Message Queuing Protocol）协议，用于在分布式系统中实现可靠的消息传递。它由Erlang编程语言开发，提供高可用性、可扩展性和稳定...
rabbitmq 3.10.2 window安装包
07-05
RabbitMQ是一个开源的消息代理和队列服务器，广泛用于分布式系统中的消息传递。它基于AMQP（Advanced Message Queuing Protocol）标准，允许应用程序之间异步通信，并提供了高可用性、可扩展性和容错性。RabbitMQ的...
【SpringCloud学习笔记】RabbitMQ（上）
weixin_62533201的博客
06-12 1392
介绍了如何基于Docker环境安装RabbitMQ、RabbitMQ相关控制台操作、基于SpringAMQP收发消息，最后介绍了WorkQueue任务模型
RabbitMQ安装及配置步骤（windows10实测顺利安装）
weixin_30641465的博客
09-15 435
1、安装Erlang 下载地址：https://www.erlang.org/downloads，本文选择OTP 21.0.1 Windows 64-bit Binary File (91707927) 设置环境变量，新建ERLANG_HOME 修改环境变量path，增加Erlang变量至path，%ERLANG_HOME%\bin; 打开cmd命令框，输入erl 至此，Erl...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值