rabbitMQ学习总结

已于 2023-04-24 16:20:51 修改
阅读量522 收藏 2
点赞数 1
文章标签： java-rabbitmq rabbitmq 学习
于 2023-04-24 16:02:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44165280/article/details/130344738
版权

RabbitMQ

  • 生产者通过-》通道-》交换机-》投到消息队列-》再通过通道-》消费者

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

  • 分布式架构

在这里插入图片描述

  • 何谓分布式系统

通俗一点: 就是一个请求由服务器端的 多个服务 (服务或者系统)协同处理完成

和单体架构不同的是，单体架构是一个请求发起ivm调度线程(确切的是tomcat线程池)分线程hread来处理请求直到释放，而分布式是系统是:一个请求是由多个系统共同来协同完成，jvm和环境都可能是独立。如果生活中的比喻的话，单体架构就想建设一个小房子很快就能够搞定，如果你要建设一个鸟巢者大型的建筑，你就必须是各个环节的协司和分布，这样目的也是项目发展都后期的时候要去部署和思考的问题

  • 中间件
    在这里插入图片描述
  • 串行与并行（异步，流量削峰）

在这里插入图片描述

  • 协议
    在这里插入图片描述

  • 什么是持久化

    简单来说就是将数据存入磁盘， 而不是存在内存中随服务器重启断开而消失，使数据能够永久保存。

  • 消息分发策略的机制对比

在这里插入图片描述

  • 高可用–》可搭建集群

rabbitMQ的入门以及安装

简单概述:

RabbitMQ是一个开源的遵循AMQP协议实现的基于Erlang语言编写，支持多种客户端(语言)。用于在分布式系统中存储消息，转发消息，具有高可用，高可扩性，易用性等特征。

rabbitmq下载地址：https://www.rabbitmq.com/download.html

下载地址就在erlang官网：https://github.com/rabbitmq/erlang-rpm/releases

笔记地址：https://www.kuangstudy.com/zl/rabbitmq#1366709584634437634

  • 解压，下载环境

rpm -Uvh erlang-25.3-1.el9.aarch64.rpm

yum install -y erlang

  • 安装成功

在这里插入图片描述

  • 启动成功
    在这里插入图片描述
  • 谨记，云服务器放开端口后，重启一下rabbitmq便可访问远程rabbitmq（web图形化）
    在这里插入图片描述
    在这里插入图片描述

rabbitmq的角色分类

在这里插入图片描述

什么是amqp

AMQP全称: Advanced Message Queuing Protocol(高级消息队列协议)。是应用层协议的一个开发标准，为面向消
息的中间件设计。

在这里插入图片描述
amqp消费者流转过程
在这里插入图片描述

  • 选择指定的交换机，指定的路由key（过滤）找到指定的值
    在这里插入图片描述
    在这里插入图片描述
  • 都会有默认交换机，由交换机发送消息，没有交换机就会默认自带的交换机
    在这里插入图片描述

Rabbitmq的六种工作模式

simple简单模式、work工作模式、publish/subscribe订阅模式、routing路由模式、topic 主题模式、RPC模式。

  1. simple简单模式为一个队列中一条消息，只能被一个消费者消费。

  2. Work工作模式为一个生产者，多个消费者，每个消费者获取到的消息唯一。

  3. publish/subscribe订阅模式为一个生产者发送的消息被多个消费者获取。

  4. routing路由模式为生产者发送的消息主要根据定义的路由规则决定往哪个队列发送。

  5. topic 主题模式为生产者，一个交换机(topicExchange)，模糊匹配路由规则，多个队列，多个消费者。

  6. RPC模式为客户端 Client 先发送消息到消息队列，远程服务端 Server 获取消息，然后再写入另一个消息队列，向原始客户端 Client 响应消息处理结果。

简单模式

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

package com.liang.rabbitmq.simple;

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

public class Producer {
    public static void main(String[] args) {
        // 所有的中间件技术都是基于tcp/ip协义基础之上构建新型的协议规范，只不过rabbitmq遵循的是amqp
        //ip port
        //1.创建连接工程

        // 1: 创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        // 2: 设置连接属性
        connectionFactory.setHost("175.178.89.93");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");
        connectionFactory.setUsername("guest");//注意账号有无权限
        connectionFactory.setPassword("guest");
        Connection connection = null;
        Channel channel = null;
        try {
            // 3: 从连接工厂中获取连接
            connection = connectionFactory.newConnection("生产者");
            // 4: 从连接中获取通道channel
            channel = connection.createChannel();
            // 5: 申明队列queue存储消息
            /*
             *  如果队列不存在，则会创建
             *  Rabbitmq不允许创建两个相同的队列名称，否则会报错。
             *  @params1： queue 队列的名称
             *  @params2： durable 队列是否持久化
             *  @params3： exclusive 是否排他，即是否私有的，如果为true,会对当前队列加锁，其他的通道不能访问，并且连接自动关闭
             *  @params4： autoDelete 是否自动删除，当最后一个消费者断开连接之后是否自动删除消息。
             *  @params5： arguments 可以设置队列附加参数，设置队列的有效期，消息的最大长度，队列的消息生命周期等等。
             * */
            channel.queueDeclare("queue1", false, false, false, null);
            // 6： 准备发送消息的内容
            String message = "你好，梁伟浩！！！";
            // 7: 发送消息给中间件rabbitmq-server
            // @params1: 交换机exchange
            // @params2: 队列名称/routing
            // @params3: 属性配置
            // @params4: 发送消息的内容
            channel.basicPublish("", "queue1", null, message.getBytes());
            System.out.println("消息发送成功!");
        } catch (Exception ex) {
            ex.printStackTrace();
            System.out.println("发送消息出现异常...");
        } finally {
            // 7: 释放连接关闭通道
            if (channel != null && channel.isOpen()) {
                try {
                    channel.close();
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
            if (connection != null) {
                try {
                    connection.close();
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
        }
    }

}

消费者

package com.liang.rabbitmq.simple;

import com.rabbitmq.client.*;

import java.io.IOException;

public class Consumer {
    public static void main(String[] args) {
        // 所有的中间件技术都是基于tcp/ip协义基础之上构建新型的协议规范，只不过rabbitmq遵循的是amqp
        //ip port
        //1.创建连接工程

        // 1: 创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        // 2: 设置连接属性
        connectionFactory.setHost("175.178.89.93");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");
        connectionFactory.setUsername("guest");//注意账号有无权限
        connectionFactory.setPassword("guest");
        Connection connection = null;
        Channel channel = null;
        try {
            // 3: 从连接工厂中获取连接
            connection = connectionFactory.newConnection("生产者");
            // 4: 从连接中获取通道channel
            channel = connection.createChannel();
            // 5: 申明队列queue存储消息
            /*
             *  如果队列不存在，则会创建
             *  Rabbitmq不允许创建两个相同的队列名称，否则会报错。
             *  @params1： queue 队列的名称
             *  @params2： durable 队列是否持久化
             *  @params3： exclusive 是否排他，即是否私有的，如果为true,会对当前队列加锁，其他的通道不能访问，并且连接自动关闭
             *  @params4： autoDelete 是否自动删除，当最后一个消费者断开连接之后是否自动删除消息。
             *  @params5： arguments 可以设置队列附加参数，设置队列的有效期，消息的最大长度，队列的消息生命周期等等。
             * */
            channel.queueDeclare("queue1", false, false, false, null);
            // 6： 准备发送消息的内容
            String message = "你好，梁伟浩！！！";
            // 7: 发送消息给中间件rabbitmq-server
            // @params1: 交换机exchange
            // @params2: 队列名称/routing
            // @params3: 属性配置
            // @params4: 发送消息的内容
            channel.basicConsume("queue1", true, new DeliverCallback() {
                public void handle(String consumer, Delivery message) throws IOException {
                    System.out.println("收到的消息是" + new String(message.getBody(), "utf-8"));
                }
            },new CancelCallback(){

                public void handle(String s) throws IOException {
                    System.out.println("接受失败");
                }
            });
            System.out.println("消息发送成功!");
        } catch (Exception ex) {
            ex.printStackTrace();
            System.out.println("发送消息出现异常...");
        } finally {
            // 7: 释放连接关闭通道
            if (channel != null && channel.isOpen()) {
                try {
                    channel.close();
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
            if (connection != null) {
                try {
                    connection.close();
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
        }
    }

}

发布与订阅模式（fanout）

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

package com.liang.rabbitmq.simple;

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

public class Producer {
    public static void main(String[] args) {
        // 所有的中间件技术都是基于tcp/ip协义基础之上构建新型的协议规范，只不过rabbitmq遵循的是amqp
        //ip port
        //1.创建连接工程

        // 1: 创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        // 2: 设置连接属性
        connectionFactory.setHost("175.178.89.93");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");
        connectionFactory.setUsername("guest");//注意账号有无权限
        connectionFactory.setPassword("guest");
        Connection connection = null;
        Channel channel = null;
        try {
            // 3: 从连接工厂中获取连接
            connection = connectionFactory.newConnection("生产者");
            // 4: 从连接中获取通道channel
            channel = connection.createChannel();
            // 5: 申明队列queue存储消息
            /*
             *  如果队列不存在，则会创建
             *  Rabbitmq不允许创建两个相同的队列名称，否则会报错。
             *  @params1： queue 队列的名称
             *  @params2： durable 队列是否持久化
             *  @params3： exclusive 是否排他，即是否私有的，如果为true,会对当前队列加锁，其他的通道不能访问，并且连接自动关闭
             *  @params4： autoDelete 是否自动删除，当最后一个消费者断开连接之后是否自动删除消息。
             *  @params5： arguments 可以设置队列附加参数，设置队列的有效期，消息的最大长度，队列的消息生命周期等等。
             * */
            channel.queueDeclare("queue1", false, false, false, null);
            // 6： 准备发送消息的内容
            String message = "你好，梁伟浩！！！";
            // 7: 发送消息给中间件rabbitmq-server
            // @params1: 交换机exchange
            String exchange = "fanout-exchange";
            // @params2: 队列名称/routing
            String routeKey = "";
            //交换机类型
            String type = "fanout";
            // @params3: 属性配置
            // @params4: 发送消息的内容
            channel.basicPublish(exchange, routeKey, null, message.getBytes());
            System.out.println("消息发送成功!");
        } catch (Exception ex) {
            ex.printStackTrace();
            System.out.println("发送消息出现异常...");
        } finally {
            // 7: 释放连接关闭通道
            if (channel != null && channel.isOpen()) {
                try {
                    channel.close();
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
            if (connection != null) {
                try {
                    connection.close();
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
        }
    }

}

路由模式（direct）

  • 增加路由key进行过滤
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
package com.liang.rabbitmq.simple;

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

public class Producer {
    public static void main(String[] args) {
        // 所有的中间件技术都是基于tcp/ip协义基础之上构建新型的协议规范，只不过rabbitmq遵循的是amqp
        //ip port
        //1.创建连接工程

        // 1: 创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        // 2: 设置连接属性
        connectionFactory.setHost("175.178.89.93");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");
        connectionFactory.setUsername("guest");//注意账号有无权限
        connectionFactory.setPassword("guest");
        Connection connection = null;
        Channel channel = null;
        try {
            // 3: 从连接工厂中获取连接
            connection = connectionFactory.newConnection("生产者");
            // 4: 从连接中获取通道channel
            channel = connection.createChannel();
            // 5: 申明队列queue存储消息
            /*
             *  如果队列不存在，则会创建
             *  Rabbitmq不允许创建两个相同的队列名称，否则会报错。
             *  @params1： queue 队列的名称
             *  @params2： durable 队列是否持久化
             *  @params3： exclusive 是否排他，即是否私有的，如果为true,会对当前队列加锁，其他的通道不能访问，并且连接自动关闭
             *  @params4： autoDelete 是否自动删除，当最后一个消费者断开连接之后是否自动删除消息。
             *  @params5： arguments 可以设置队列附加参数，设置队列的有效期，消息的最大长度，队列的消息生命周期等等。
             * */
            channel.queueDeclare("queue1", false, false, false, null);
            // 6： 准备发送消息的内容
            String message = "你好，梁伟浩！！！";
            // 7: 发送消息给中间件rabbitmq-server
            // @params1: 交换机exchange
            String exchange = "direct-exchange";
            // @params2: 队列名称/routing
            String routeKey = "email";//对应是queue1
            //交换机类型
            String type = "direct";
            // @params3: 属性配置
            // @params4: 发送消息的内容
            channel.basicPublish(exchange, routeKey, null, message.getBytes());
            System.out.println("消息发送成功!");
        } catch (Exception ex) {
            ex.printStackTrace();
            System.out.println("发送消息出现异常...");
        } finally {
            // 7: 释放连接关闭通道
            if (channel != null && channel.isOpen()) {
                try {
                    channel.close();
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
            if (connection != null) {
                try {
                    connection.close();
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
        }
    }

}

主题模式(topic)

在这里插入图片描述

#代表一个或者多个多级，可有可无
*有且只有一个，一定要有

在这里插入图片描述

package com.liang.rabbitmq.simple;

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

public class Producer {
    public static void main(String[] args) {
        // 所有的中间件技术都是基于tcp/ip协义基础之上构建新型的协议规范，只不过rabbitmq遵循的是amqp
        //ip port
        //1.创建连接工程

        // 1: 创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        // 2: 设置连接属性
        connectionFactory.setHost("175.178.89.93");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");
        connectionFactory.setUsername("guest");//注意账号有无权限
        connectionFactory.setPassword("guest");
        Connection connection = null;
        Channel channel = null;
        try {
            // 3: 从连接工厂中获取连接
            connection = connectionFactory.newConnection("生产者");
            // 4: 从连接中获取通道channel
            channel = connection.createChannel();
            // 5: 申明队列queue存储消息
            /*
             *  如果队列不存在，则会创建
             *  Rabbitmq不允许创建两个相同的队列名称，否则会报错。
             *  @params1： queue 队列的名称
             *  @params2： durable 队列是否持久化
             *  @params3： exclusive 是否排他，即是否私有的，如果为true,会对当前队列加锁，其他的通道不能访问，并且连接自动关闭
             *  @params4： autoDelete 是否自动删除，当最后一个消费者断开连接之后是否自动删除消息。
             *  @params5： arguments 可以设置队列附加参数，设置队列的有效期，消息的最大长度，队列的消息生命周期等等。
             * */
            channel.queueDeclare("queue1", false, false, false, null);
            // 6： 准备发送消息的内容
            String message = "你好，梁伟浩！！！";
            // 7: 发送消息给中间件rabbitmq-server
            // @params1: 交换机exchange
            String exchange = "topic-exchange";
            // @params2: 队列名称/routing
            String routeKey = "com.course.user";//对应是queue1
            //交换机类型
            String type = "topic";
            // @params3: 属性配置
            // @params4: 发送消息的内容
            channel.basicPublish(exchange, routeKey, null, message.getBytes());
            System.out.println("消息发送成功!");
        } catch (Exception ex) {
            ex.printStackTrace();
            System.out.println("发送消息出现异常...");
        } finally {
            // 7: 释放连接关闭通道
            if (channel != null && channel.isOpen()) {
                try {
                    channel.close();
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
            if (connection != null) {
                try {
                    connection.close();
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
        }
    }

}

work模式-轮询模式（round-robin）

  • 类型：无
  • 特点：该模式接收消息是当有多个消费者接入时，消息的分配摸式是一个消费者分配一条，直至消息消费完战

轮询

生产者

package com.liang.rabbitmq.work.fair;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

public class Producer {
    public static void main(String[] args) {
        // 1: 创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        // 2: 设置连接属性
        connectionFactory.setHost("175.178.89.93");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");
        Connection connection = null;
        Channel channel = null;
        try {
            // 3: 从连接工厂中获取连接
            connection = connectionFactory.newConnection("生产者");
            // 4: 从连接中获取通道channel
            channel = connection.createChannel();
            // 6： 准备发送消息的内容
            //===============================end topic模式==================================
            for (int i = 1; i <= 20; i++) {
                //消息的内容
                String msg = "lwh:" + i;
                // 7: 发送消息给中间件rabbitmq-server
                // @params1: 交换机exchange
                // @params2: 队列名称/routingkey
                // @params3: 属性配置
                // @params4: 发送消息的内容
                channel.basicPublish("", "queue8", null, msg.getBytes());
            }
            System.out.println("消息发送成功!");
        } catch (Exception ex) {
            ex.printStackTrace();
            System.out.println("发送消息出现异常...");
        } finally {
            // 7: 释放连接关闭通道
            if (channel != null && channel.isOpen()) {
                try {
                    channel.close();
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
            if (connection != null) {
                try {
                    connection.close();
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
        }
    }
}

消费者1

package com.liang.rabbitmq.work.lunxun;
import com.rabbitmq.client.*;
import java.io.IOException;

public class Work1 {
    public static void main(String[] args) {
        // 1: 创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        // 2: 设置连接属性
        connectionFactory.setHost("175.178.89.93");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");
        Connection connection = null;
        Channel channel = null;
        try {
            // 3: 从连接工厂中获取连接
            connection = connectionFactory.newConnection("消费者-Work1");
            // 4: 从连接中获取通道channel
            channel = connection.createChannel();
            // 5: 申明队列queue存储消息
            /*
             *  如果队列不存在，则会创建
             *  Rabbitmq不允许创建两个相同的队列名称，否则会报错。
             *
             *  @params1： queue 队列的名称
             *  @params2： durable 队列是否持久化
             *  @params3： exclusive 是否排他，即是否私有的，如果为true,会对当前队列加锁，其他的通道不能访问，并且连接自动关闭
             *  @params4： autoDelete 是否自动删除，当最后一个消费者断开连接之后是否自动删除消息。
             *  @params5： arguments 可以设置队列附加参数，设置队列的有效期，消息的最大长度，队列的消息生命周期等等。
             * */
            // 这里如果queue已经被创建过一次了，可以不需要定义
//            channel.queueDeclare("queue1", false, false, false, null);
            // 同一时刻，服务器只会推送一条消息给消费者
            // 6： 定义接受消息的回调
            Channel finalChannel = channel;
            finalChannel.basicQos(1);
            finalChannel.basicConsume("queue8", true, new DeliverCallback() {
                @Override
                public void handle(String s, Delivery delivery) throws IOException {
                    try{
                        System.out.println("Work1-收到消息是：" + new String(delivery.getBody(), "UTF-8"));
                        Thread.sleep(200);
                    }catch(Exception ex){
                        ex.printStackTrace();
                    }
                }
            }, new CancelCallback() {
                @Override
                public void handle(String s) throws IOException {
                }
            });
            System.out.println("Work1-开始接受消息");
            System.in.read();
        } catch (Exception ex) {
            ex.printStackTrace();
            System.out.println("发送消息出现异常...");
        } finally {
            // 7: 释放连接关闭通道
            if (channel != null && channel.isOpen()) {
                try {
                    channel.close();
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
            if (connection != null && connection.isOpen()) {
                try {
                    connection.close();
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
        }
    }
}

消费者2

package com.liang.rabbitmq.work.lunxun;
import com.rabbitmq.client.*;
import java.io.IOException;

public class Work2 {
    public static void main(String[] args) {
        // 1: 创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        // 2: 设置连接属性
        connectionFactory.setHost("175.178.89.93");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");
        Connection connection = null;
        Channel channel = null;
        try {
            // 3: 从连接工厂中获取连接
            connection = connectionFactory.newConnection("消费者-Work2");
            // 4: 从连接中获取通道channel
            channel = connection.createChannel();
            // 5: 申明队列queue存储消息
            /*
             *  如果队列不存在，则会创建
             *  Rabbitmq不允许创建两个相同的队列名称，否则会报错。
             *
             *  @params1： queue 队列的名称
             *  @params2： durable 队列是否持久化
             *  @params3： exclusive 是否排他，即是否私有的，如果为true,会对当前队列加锁，其他的通道不能访问，并且连接自动关闭
             *  @params4： autoDelete 是否自动删除，当最后一个消费者断开连接之后是否自动删除消息。
             *  @params5： arguments 可以设置队列附加参数，设置队列的有效期，消息的最大长度，队列的消息生命周期等等。
             * */
            // 这里如果queue已经被创建过一次了，可以不需要定义
            //channel.queueDeclare("queue1", false, true, false, null);
            // 同一时刻，服务器只会推送一条消息给消费者
            //channel.basicQos(1);
            // 6： 定义接受消息的回调
            Channel finalChannel = channel;
            finalChannel.basicQos(1);
            finalChannel.basicConsume("queue8", true, new DeliverCallback() {
                @Override
                public void handle(String s, Delivery delivery) throws IOException {
                    try{
                        System.out.println("Work2-收到消息是：" + new String(delivery.getBody(), "UTF-8"));
                        Thread.sleep(1000);
                    }catch(Exception ex){
                        ex.printStackTrace();
                    }
                }
            }, new CancelCallback() {
                @Override
                public void handle(String s) throws IOException {
                }
            });
            System.out.println("Work2-开始接受消息");
            System.in.read();
        } catch (Exception ex) {
            ex.printStackTrace();
            System.out.println("发送消息出现异常...");
        } finally {
            // 7: 释放连接关闭通道
            if (channel != null && channel.isOpen()) {
                try {
                    channel.close();
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
            if (connection != null && connection.isOpen()) {
                try {
                    connection.close();
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
        }
    }
}

公平分发（能者多得），需要手动应答

消费者1

package com.liang.rabbitmq.work.fair;

import com.rabbitmq.client.*;

import java.io.IOException;

public class Work1 {
    public static void main(String[] args) {
        // 1: 创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        // 2: 设置连接属性
        connectionFactory.setHost("175.178.89.93");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");
        Connection connection = null;
        Channel channel = null;
        try {
            // 3: 从连接工厂中获取连接
            connection = connectionFactory.newConnection("消费者-Work1");
            // 4: 从连接中获取通道channel
            channel = connection.createChannel();
            // 5: 申明队列queue存储消息
            /*
             *  如果队列不存在，则会创建
             *  Rabbitmq不允许创建两个相同的队列名称，否则会报错。
             *
             *  @params1： queue 队列的名称
             *  @params2： durable 队列是否持久化
             *  @params3： exclusive 是否排他，即是否私有的，如果为true,会对当前队列加锁，其他的通道不能访问，并且连接自动关闭
             *  @params4： autoDelete 是否自动删除，当最后一个消费者断开连接之后是否自动删除消息。
             *  @params5： arguments 可以设置队列附加参数，设置队列的有效期，消息的最大长度，队列的消息生命周期等等。
             * */
            // 这里如果queue已经被创建过一次了，可以不需要定义
//            channel.queueDeclare("queue1", false, false, false, null);
            // 同一时刻，服务器只会推送一条消息给消费者
            // 6： 定义接受消息的回调
            final Channel finalChannel = channel;
            finalChannel.basicQos(1);
            finalChannel.basicConsume("queue8", false, new DeliverCallback() {
                @Override
                public void handle(String s, Delivery delivery) throws IOException {
                    try{
                        System.out.println("Work1-收到消息是：" + new String(delivery.getBody(), "UTF-8"));
                        Thread.sleep(1000);
                       //改成手动应答
                        finalChannel.basicAck(delivery.getEnvelope().getDeliveryTag(),false);
                    }catch(Exception ex){
                        ex.printStackTrace();
                    }
                }
            }, new CancelCallback() {
                @Override
                public void handle(String s) throws IOException {
                }
            });
            System.out.println("Work1-开始接受消息");
            System.in.read();
        } catch (Exception ex) {
            ex.printStackTrace();
            System.out.println("发送消息出现异常...");
        } finally {
            // 7: 释放连接关闭通道
            if (channel != null && channel.isOpen()) {
                try {
                    channel.close();
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
            if (connection != null && connection.isOpen()) {
                try {
                    connection.close();
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
        }
    }
}

消费者2

package com.liang.rabbitmq.work.fair;

import com.rabbitmq.client.*;

import java.io.IOException;

public class Work2 {
    public static void main(String[] args) {
        // 1: 创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        // 2: 设置连接属性
        connectionFactory.setHost("175.178.89.93");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");
        Connection connection = null;
        Channel channel = null;
        try {
            // 3: 从连接工厂中获取连接
            connection = connectionFactory.newConnection("消费者-Work2");
            // 4: 从连接中获取通道channel
            channel = connection.createChannel();
            // 5: 申明队列queue存储消息
            /*
             *  如果队列不存在，则会创建
             *  Rabbitmq不允许创建两个相同的队列名称，否则会报错。
             *
             *  @params1： queue 队列的名称
             *  @params2： durable 队列是否持久化
             *  @params3： exclusive 是否排他，即是否私有的，如果为true,会对当前队列加锁，其他的通道不能访问，并且连接自动关闭
             *  @params4： autoDelete 是否自动删除，当最后一个消费者断开连接之后是否自动删除消息。
             *  @params5： arguments 可以设置队列附加参数，设置队列的有效期，消息的最大长度，队列的消息生命周期等等。
             * */
            // 这里如果queue已经被创建过一次了，可以不需要定义
            //channel.queueDeclare("queue1", false, true, false, null);
            // 同一时刻，服务器只会推送一条消息给消费者
            //channel.basicQos(1);
            // 6： 定义接受消息的回调
            final Channel finalChannel = channel;
            finalChannel.basicQos(1);
            finalChannel.basicConsume("queue8", false, new DeliverCallback() {
                @Override
                public void handle(String s, Delivery delivery) throws IOException {
                    try{
                        System.out.println("Work2-收到消息是：" + new String(delivery.getBody(), "UTF-8"));
                        Thread.sleep(3000);
                        finalChannel.basicAck(delivery.getEnvelope().getDeliveryTag(),false);
                    }catch(Exception ex){
                        ex.printStackTrace();
                    }
                }
            }, new CancelCallback() {
                @Override
                public void handle(String s) throws IOException {
                }
            });
            System.out.println("Work2-开始接受消息");
            System.in.read();
        } catch (Exception ex) {
            ex.printStackTrace();
            System.out.println("发送消息出现异常...");
        } finally {
            // 7: 释放连接关闭通道
            if (channel != null && channel.isOpen()) {
                try {
                    channel.close();
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
            if (connection != null && connection.isOpen()) {
                try {
                    connection.close();
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
        }
    }
}

参数模式

  • 创立交换机选择对应的type
    在这里插入图片描述

代码创建交换机并绑定队列

  • 如果消费一个不存在的队列会直接报错
    在这里插入图片描述
package com.liang.rabbitmq.simple;

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

public class Producer {
    public static void main(String[] args) {
        // 所有的中间件技术都是基于tcp/ip协义基础之上构建新型的协议规范，只不过rabbitmq遵循的是amqp
        //ip port
        //1.创建连接工程

        // 1: 创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        // 2: 设置连接属性
        connectionFactory.setHost("175.178.89.93");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");
        connectionFactory.setUsername("guest");//注意账号有无权限
        connectionFactory.setPassword("guest");
        Connection connection = null;
        Channel channel = null;
        try {
            // 3: 从连接工厂中获取连接
            connection = connectionFactory.newConnection("生产者");
            // 4: 从连接中获取通道channel
            channel = connection.createChannel();
            // 5: 申明队列queue存储消息
            /*
             *  如果队列不存在，则会创建
             *  Rabbitmq不允许创建两个相同的队列名称，否则会报错。
             *  @params1： queue 队列的名称
             *  @params2： durable 队列是否持久化
             *  @params3： exclusive 是否排他，即是否私有的，如果为true,会对当前队列加锁，其他的通道不能访问，并且连接自动关闭
             *  @params4： autoDelete 是否自动删除，当最后一个消费者断开连接之后是否自动删除消息。
             *  @params5： arguments 可以设置队列附加参数，设置队列的有效期，消息的最大长度，队列的消息生命周期等等。
             * */
            channel.queueDeclare("queue1", false, false, false, null);
            // 6： 准备发送消息的内容
            String message = "你好，梁伟浩！！！";
            // 7: 发送消息给中间件rabbitmq-server
            // @params1: 交换机exchange
            String exchange = "direct-message-exchange";
            // @params2: 队列名称/routing
            String routeKey = "";//对应是queue1
            //交换机类型
            String type = "direct";
            // @params3: 属性配置
            // @params4: 发送消息的内容
            //交换机会不会随者服务器重启造成丢失，如果是true代表不丢失，false重启就会去失
            channel.exchangeDeclare(exchange, type,true);
            //声明队列
            channel.queueDeclare("queue5", true,false,false,null);
            channel.queueDeclare("queue6", true,false,false,null);
            channel.queueDeclare("queue7", true,false,false,null);
            //绑定队列与交换机的关系
            channel.queueBind("queue5", exchange,"order");
            channel.queueBind("queue6", exchange,"order");
            channel.queueBind("queue7", exchange,"course");


            channel.basicPublish(exchange, "order", null, message.getBytes());
            System.out.println("消息发送成功!");
        } catch (Exception ex) {
            ex.printStackTrace();
            System.out.println("发送消息出现异常...");
        } finally {
            // 7: 释放连接关闭通道
            if (channel != null && channel.isOpen()) {
                try {
                    channel.close();
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
            if (connection != null) {
                try {
                    connection.close();
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
        }
    }

}

当有多个消费者时，我们的消息会被哪个消费者消费呢，我们又该如何均衡消费者消费信息的多少呢:主要有两种模式:

  • 论询模式的分发:个消费者条，按均分配;

  • 公平分发: 根据消费的消费，讲行公平分发，处理快的处理的多，处理悍的处理的少;按劳分配;

rabbitmq使用场景

  • 解耦、削峰、异步
  • 高内聚低耦合

C:\Users\86151\AppData\Roaming\Typora\typora-user-images\image-20230420140930963.png)]
在这里插入图片描述
在这里插入图片描述

  • 静态方法只能调用静态方法

  • 版本问题

  • 注意yml和properties配置文件

  • @Configuration加这个@bean项目启动自动扫描编译运行

  • @Configuration表示springboot会自动扫描 @bean

  • 在Spring框架中，Bean是最基本的组件，它是Spring框架中的一个Java对象。在实例化阶段，Spring框架会创建Bean实例，并根据Bean的定义，注入Bean的属性和依赖关系。

  • 在实例化阶段完成后，Spring框架会对Bean进行初始化。在初始化阶段，Spring框架会调用Bean的初始化方法，并执行各种初始化操作，例如数据源的初始化、连接的建立等

fanout消费者

在对应的消费者类加上注解并注明到spring组件会自动对队列的消息进行消费

  • @Component
  • @service
@Component
@RabbitListener(queues = {"duanxin.fanout.queue"})
public class FanoutdaunxinConsumer {

    @RabbitHandler
    public void reviceMessage(String message){
        System.out.println("duanxin.fanout.queue==接收到的订单信息是"+message);
    }

springboot整合direct模式

  • 比fanout多一个路由key进行过滤

  • @bean方法的名称不可以重复，否则会报错

  • 生产者

  • config类

package com.liang.rabbitmqspringboot.config;

import org.springframework.amqp.core.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class DirectRabbitMqConfiguration {
//: 声明注册direct模式的交换机

    @Bean
    public DirectExchange directExchange(){
    return new DirectExchange("direct_order_exchange",true,false);
        }

// 2: 声明队列 sms.fanout.queue email.fanout.queue,duanxin.fanout.queue
    @Bean
    public Queue smsQueueDirect(){
        System.out.println("9999999999999999999999999999999999999999999999999999999999999999");
        return new Queue("sms.direct.queue",true);
    }

    @Bean
    public Queue duanxinQueueDirect(){
        System.out.println("888888888888888888888888888888888888888888888888888888888888");
        return new Queue("duanxin.direct.queue",true);
    }

    @Bean
    public Queue emailQueueDirect(){
        System.out.println("11111111111111111111111111111111111111111111");
        return new Queue("email.direct.queue",true);
    }

// 3: 完成绑定关系(队列和交换机完成绑定关系)
    @Bean
    public Binding smsBingdingDirect(){
        return BindingBuilder.bind(smsQueueDirect()).to(directExchange()).with("sms");
    }

    @Bean
    public Binding duanxinBingdingDirect(){
        return BindingBuilder.bind(duanxinQueueDirect()).to(directExchange()).with("duanxin");
    }
    @Bean
    public Binding emailBingdingDirect(){
        return BindingBuilder.bind(emailQueueDirect()).to(directExchange()).with("email");
    }


}
  • service类
package com.liang.rabbitmqspringboot.service;

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.UUID;

@Service
public class OrderService {

    @Autowired
    private  RabbitTemplate rabbitTemplate;

    public void makeOrder(String userid, String productid, int num){
        // 1: 根据商品id查询库存是否充足
        // 2: 保存订单
        String orderid = UUID.randomUUID().toString();
        System.out.println("订单生成成功"+orderid);
         3: 通过Mp来完成消息的分发
        //参数1: 交换机 参数2:路中key/queue队列名称 参数3:消息内容
        String exchangeName = "fanout_order_exchange";
        String routingKey = "";
        rabbitTemplate.convertAndSend(exchangeName,routingKey,orderid);

    }

    public void makeOrderDirect(String userid, String productid, int num){
        // 1: 根据商品id查询库存是否充足
        // 2: 保存订单
        String orderid = UUID.randomUUID().toString();
        System.out.println("订单生成成功"+orderid);
         3: 通过Mp来完成消息的分发
        //参数1: 交换机 参数2:路中key/queue队列名称 参数3:消息内容
        String exchangeName = "direct_order_exchange";
        rabbitTemplate.convertAndSend(exchangeName,"email",orderid);
        rabbitTemplate.convertAndSend(exchangeName,"duanxin",orderid);

    }
}
  • 测试类
package com.liang.rabbitmqspringboot;

import com.liang.rabbitmqspringboot.service.OrderService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import sun.applet.Main;

@SpringBootTest
class RabbitmqSpringbootApplicationTests {

    @Autowired
    private OrderService orderService;

    @Test
    void contextLoads() {
        orderService.makeOrder("2", "2", 12);
    }
    @Test
    void contextLoadsDirect() {
        orderService.makeOrderDirect("3", "3", 13);
    }

}

springboot整合主题模式

package com.liang.rabbitmqspringbootconsumer.service.topic;

import org.springframework.amqp.core.ExchangeTypes;
import org.springframework.amqp.rabbit.annotation.*;
import org.springframework.stereotype.Component;

@Component
@RabbitListener(bindings = @QueueBinding(
        value = @Queue(value = "sms.topic.queue",durable = "true"
                ,autoDelete = "false"),
        exchange = @Exchange(value = "topic_order_exchange",
                type = ExchangeTypes.TOPIC),
        key = "#.com.#"
))
public class TopicSmsConsumer {

    @RabbitHandler
    public void reviceMessage(String message){
        System.out.println("sms.topic.queue==接收到的订单信息是"+message);
    }

}

rabbitQM-过期时间TTL

过期时间TTL表示可以对消息设置预期的时间，在这个时间内都可以被消费者接收获取，过了之后消息将自动被删除RabbitMO可以对 消息和队列 设置TTL。目前有两种方法可以设置。

  • ttl队列过期时间，过期消息的时候移除到死性队列中（queue会显示有ttl标识）
  • ttl消息过期时间，直接移除掉过期信息

在这里插入图片描述

  • config
package com.liang.rabbitmqspringboot.config;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.DirectExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.HashMap;
import java.util.Map;

@Configuration
public class ttlRabbitMqConfiguration {
//: 声明注册direct模式的交换机

    @Bean
    public DirectExchange ttlDirectExchange(){
        return new DirectExchange("direct_order_exchange",true,false);
    }

    // 2: 声明队列 sms.fanout.queue email.fanout.queue,duanxin.fanout.queue
    @Bean
    public Queue smsQueuettlDirect(){
        Map<String, Object> args = new HashMap<>();
        args.put("x-message-ttl", 5000);//int类型
        return new Queue("ttl.direct.queue",true,false,false,args);
    }

    @Bean
    public Queue smsQueuettlDirectMessage(){
        return new Queue("ttl.message.direct.queue",true);
    }

    @Bean
    public Binding emailBingdingDirectTTL(){
        return BindingBuilder.bind(smsQueuettlDirectMessage()).to(ttlDirectExchange()).with("ttl");
    }
    @Bean
    public Binding emailBingdingDirectTTLmessage(){
        return BindingBuilder.bind(ttlDirectExchange()).to(ttlDirectExchange()).with("ttlMessage");
    }


}

在这里插入图片描述

    public void makeOrderTTL(String userid, String productid, int num){
        // 1: 根据商品id查询库存是否充足
        // 2: 保存订单
        String orderid = UUID.randomUUID().toString();
        System.out.println("订单生成成功"+orderid);
         3: 通过Mp来完成消息的分发
        //参数1: 交换机 参数2:路中key/queue队列名称 参数3:消息内容
        String exchangeName = "ttl_direct_exchange";
        String routKey  = "ttl";
        rabbitTemplate.convertAndSend(exchangeName,routKey,orderid);

    }

    public void makeOrderTTLMessage(String userid, String productid, int num){
        // 1: 根据商品id查询库存是否充足
        // 2: 保存订单
        String orderid = UUID.randomUUID().toString();
        System.out.println("订单生成成功"+orderid);
         3: 通过Mp来完成消息的分发
        //参数1: 交换机 参数2:路中key/queue队列名称 参数3:消息内容
        String exchangeName = "ttl_direct_exchange";
        String routKey  = "ttlMessage";

        MessagePostProcessor messagePostProcessor = new MessagePostProcessor() {
            @Override
            public Message postProcessMessage(Message message) throws AmqpException {
              message.getMessageProperties().setExpiration("5000");
              message.getMessageProperties().setContentEncoding("utf-8");
                return message;
            }
        };
        rabbitTemplate.convertAndSend(exchangeName,routKey,orderid,messagePostProcessor);
    }

死信队列

DLX，全称为Dead-Letter-Exchange,可以称之为死信交换机，也有人称之为死信邮箱。当消息在一个队列中变成死信dead message)之后，它能被重新发送到另一个交换机中，这个交换机就是DLX，绑定DLX的队列就称之为死信队列.消息变成死信，可能是由于以下的原区”
。消息被拒绝
。消息过期
。队列达到最大长度

  • 设置死信队列
    @Bean
    public Queue smsQueuettlDirect(){
        Map<String, Object> args = new HashMap<>();
        args.put("x-message-ttl", 5000);//int类型
        args.put("x-dead-letter-exchange", "dead_direct_exchange");
        args.put("x-dead-letter-routing-key", "dead");//fanout不需要路由key
        return new Queue("ttl.direct.queue",true,false,false,args);
    }
  • 消息队列过期后会到对应设置的死信队列中
    在这里插入图片描述
  • 内存不足（Memory）
    在这里插入图片描述
    在这里插入图片描述
  • 内存换页，把内存的值设置到0.5百分比左右，消息转移到磁盘里，因为磁盘比内存大的多得多

rabbitMQ集群

  • 从节点挂了，数据不会丢失
  • 主节点挂了，从节点无法启动
Java中的战斗机
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
RabbitMQ学习总结
Qulishas的博客
06-24 272
RabbitMQ 简介 消息中间件 什么是中间件呢？ 　　非底层操作系统软件，非业务应用软件，不是直接给最终用户使用的，不能直接给客户带来价值的软件统称为中间件。 什么是消息中间件? 　　消息中间件利用高效可靠的消息传递机制进行平台无关的数据交流，并基于数据通信来进行分布式系统的集成。通过提供消息传递和消息排队模型，它可以在分布式环境下扩展进程间的通信。 JMS 　　java消息服务(Java Message Service)即JMS，是一个Java平台中关于面向消息中间件的api，用于在两
RabbitMQ知识点总结
ghh_all4you的专栏
04-01 250
为什么要使用MQ 解耦、异步、削峰 解耦：传统应用，应用之前互相调用都是通过API调用的，耦合性强，如果有新的应用接入，则会造成多个应用的代码修改；但是中间加上MQ中间件，这种 耦合性就会变得非常低，应用接入退出都会变的异常简单。 异步：传统应用调用多个应用时，需要同步调用，消耗时间为多个调用的总和，加入MQ组件后，只需要把消息发送给MQ后就可以返回，减少应用的等待时间。 此处有一个疑问，解决异步...
RabbitMq 学习总结
George_huhu的博客
03-25 590
Spring AMQP
Springboot整合RabbitMq学习
01-05
SpringBoot整合RabbitMQ的学习是一个重要的主题，尤其对于那些希望在Java环境中构建高效、可扩展的消息传递系统的开发者来说。RabbitMQ是一个开源的消息代理和队列服务器，它使用AMQP（Advanced Message Queuing ...
rabbitmq学习资料
01-30
【RabbitMQ 学习资料】这篇文档是针对初学者准备的，主要涵盖了RabbitMQ的基本概念、消息队列的工作原理、AMQP和JMS的区别、常见消息中间件的对比，以及RabbitMQ的安装与配置，还有其提供的Web管理界面和基本功能。...
RabbitMQ学习讲义
11-17
【RabbitMQ学习讲义】 RabbitMQ是一个开源的消息队列系统，它基于高级消息队列协议（AMQP）实现，旨在提供可靠的、跨平台的消息传递。AMQP是一种应用程序层的开放标准，允许不同的系统、语言和应用之间进行无缝的...
ActiveMQ学习总结
02-24
1.在网络通讯中，Http请求默认采用同步请求方式，基于请求与响应模式2....目前使用较多的消息队列有ActiveMQ，RabbitMQ，ZeroMQ，Kafka，MetaMQ，RocketMQ实现方式:面向消息的中间件(MessageOrlentedMiddlewareMO
SpringBoot日常：封装rabbitmq starter组件
qq_32590535的博客
07-08 909
本章内容主要介绍编写一个rabbitmq starter，能够通过配置文件进行配置交换机、队列以及绑定关系等等。项目引用该组件后能够自动初始化交换机和队列，并进行简单通信。 如若有其他需求，可自行扩展，例如消息消费的确认等
RabbitMQ中常用的三种交换机【Fanout、Direct、Topic】
LYJbao的博客
07-07 833
此时支付服务会把支付结果发送到交换机中，而短信服务就会去监听这个交换机，但是交换机不会把所有的消息都路由给短信服务，而只把支付成功的消息路由给这个短信服务。这种情况下，就需要使用到这个Direct交换机，短信服务下的队列和这个交换机设置一个key（例如：success），支付服务发消息时，支付成功RoutingKey设为success，失败为fail，交换机就会只把key为success的消息路由给短信服务了~上图中，就是，key为blue，消费者1去消费；一个只能接到新闻，一个只能接到和中国相关的消息~
RabbitMQ 迁移
Dablelv 的博客专栏。
07-08 493
如果您只需要导出和导入RabbitMQ的定义（如vhost、exchange、queue等），可以使用RabbitMQ的 HTTP API。
RabbitMQ 高级功能
Casual_Lei的博客
07-11 1049
RabbitMQ 是一个广泛使用的开源消息代理，它支持多种消息传递协议，可以在分布式系统中用于可靠的消息传递。除了基本的消息队列功能外，RabbitMQ 还提供了一些高级功能，增强了其在高可用性、扩展性和灵活性方面的能力。
egg.js使用消息队列rabbitMQ
deng_zhihao692817的专栏
07-11 252
P 是我们的生产者 > 中间的框是一个队列,代表消费者保留的消息缓冲区 > C 是我们的消费者。1. egg-amqplib： 基于 rabbitmq 消息队列封装的库。2. 安装rabbitmq， 可使用docker安装rabbitmq。访问地址： http://localhost:15672。默认的账号密码是： guest : guest。4. 队列： 一对多。3. 队列: 一对一。
RabbitMq,通过prefetchCount限制消费并发数
hit、run
07-08 302
RabbitMq,通过prefetchCount限制消费并发数
Autoware.universe 高效学习第三章 -- 智驾技术务虚会之智驾技术栈讨论 其一
cy1641395022的博客
07-10 645
Autoware.universe 高效学习第三章 -- 智驾技术务虚会之智驾技术栈讨论 其一
ROS基础学习-ROS运行管理
最新发布
周陽讀書
07-11 461
ROS运行管理。
jmeter-beanshell学习5-beanshell加减乘除运算
朱文宇的博客
07-08 280
jmeter使用beanshell，jmeter beanshell脚本编写，beanshell进行加减乘除运算
rabbitMQ学习心得
01-13
根据提供的内容，很难获得关于"rabbitMQ学习心得"和"rabbitMQ使用文档"的具体信息。因此，以下是一个2000字的总结描述，包含有关rabbitMQ的一般信息和可能对读者有用的相关内容。 总结：RabbitMQ是一个流行的开源...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Java中的战斗机

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值