RabbitMQ的基本入门

Posted 2020-12-21 codeli

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了RabbitMQ的基本入门相关的知识，希望对你有一定的参考价值。

RabbitMQ的基本使用

一、引言

模块之间的耦合度多高，导致一个模块宕机后，全部功能都不能用了，

并且同步通讯的成本过高，用户体验差。

RabbitMQ引言

二、RabbitMQ介绍

市面上比较火爆的几款MQ：

ActiveMQ，RocketMQ，Kafka，RabbitMQ。

语言的支持：ActiveMQ，RocketMQ只支持Java语言，Kafka可以支持多们语言，RabbitMQ支持多种语言。

效率方面：ActiveMQ，RocketMQ，Kafka效率都是毫秒级别，RabbitMQ是微秒级别的。

消息丢失，消息重复问题： RabbitMQ针对消息的持久化，和重复问题都有比较成熟的解决方案。

学习成本：RabbitMQ非常简单。

RabbitMQ是由Rabbit公司去研发和维护的，最终是在Pivotal。

RabbitMQ严格的遵循AMQP协议，高级消息队列协议，帮助我们在进程之间传递异步消息。

三、RabbitMQ安装

version: "3.1"
services:
  rabbitmq:
    image: daocloud.io/library/rabbitmq:management
    restart: always
    container_name: rabbitmq
    ports:
      - 5672:5672
      - 15672:15672
    volumes:
      - ./data:/var/lib/rabbitmq

四、RabbitMQ架构【`重点`】

4.1 官方的简单架构图

Publisher - 生产者：发布消息到RabbitMQ中的Exchange

Consumer - 消费者：监听RabbitMQ中的Queue中的消息

Exchange - 交换机：和生产者建立连接并接收生产者的消息

Queue - 队列：Exchange会将消息分发到指定的Queue，Queue和消费者进行交互

Routes - 路由：交换机以什么样的策略将消息发布到Queue

简单架构图

4.2 RabbitMQ的完整架构图

完整架构图

完整架构图

4.3 查看图形化界面并创建一个Virtual Host

创建一个全新的用户和全新的Virtual Host，并且将test用户设置上可以操作/test的权限

监控界面

Ready：待消费的消息总数。
Unacked：待应答（待确认）的消息总数。
Total：总数 Ready+Unacked。

五、RabbitMQ的使用【`重点`】

5.1 RabbitMQ的通讯方式

通讯方式

5.2 Java连接RabbitMQ

5.2.1 创建maven项目

…………

5.2.2 导入依赖

<dependencies>
    <dependency>
        <groupId>com.rabbitmq</groupId>
        <artifactId>amqp-client</artifactId>
        <version>5.6.0</version>
    </dependency>

    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
</dependencies>

5.2.3 创建工具类连接RabbitMQ

public static Connection getConnection(){
    // 创建Connection工厂
    ConnectionFactory factory = new ConnectionFactory();
    factory.setHost("192.168.199.109");
    factory.setPort(5672);
    factory.setUsername("test");
    factory.setPassword("test");
    factory.setVirtualHost("/test");

    // 创建Connection
    Connection conn = null;
    try {
        conn = factory.newConnection();
    } catch (Exception e) {
        e.printStackTrace();
    }
    // 返回
    return conn;
}

5.2.4 测试连接

    @Test
    public void test1(){
        Connection connection = RabbitMQClient.getConnection();
        System.out.println(connection);
        try {
            connection.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

效果图

5.3 Hello-World

一个生产者，一个默认的交换机，一个队列，一个消费者

结构图

创建生产者，创建一个channel，发布消息到exchange，指定路由规则。

@Test
public void publish() throws Exception {
    //1. 获取Connection
    Connection connection = RabbitMQClient.getConnection();

    //2. 创建Channel
    Channel channel = connection.createChannel();
    /**
         * queue: 队列名称
         * durable： 是否持久化, 队列的声明默认是存放到内存中的
         * exclusive：是否排外的
         * autoDelete：是否自动删除
         * arguments：队列中的消息什么时候会自动被删除
         */
    //3、创建一个队列
    channel.queueDeclare("hello-queue",true,false,false,null);
    //4. 发布消息到exchange，同时指定路由的规则
    String msg = "Hello-World！";
    // 参数1：指定exchange，使用""，使用默认的交换机
    // 参数2：指定路由的规则，使用具体的队列名称。
    // 参数3：指定传递的消息所携带的properties，使用null。
    // 参数4：指定发布的具体消息，byte[]类型
    channel.basicPublish("","HelloWorld",null,msg.getBytes());
    // Ps：exchange是不会帮你将消息持久化到本地的，Queue才会帮你持久化消息。
    System.out.println("生产者发布消息成功！");
    //5. 释放资源
    channel.close();
    connection.close();
}

创建消费者，创建一个channel，创建一个队列，并且去消费当前队列

@Test
public void consume() throws Exception {
    //1. 获取连接对象
    Connection connection = RabbitMQClient.getConnection();

    //2. 创建channel
    Channel channel = connection.createChannel();

    //3. 声明队列-HelloWorld
    //参数1：queue - 指定队列的名称
    //参数2：durable - 当前队列是否需要持久化（true，设置false后MQ重启后队列全部删除）
    //参数3：exclusive - 是否排外（conn.close() - 当前队列会被自动删除，当前队列只能被一个消费者消费）
    //参数4：autoDelete - 如果这个队列没有消费者在消费，队列自动删除
    //参数5：arguments - 指定当前队列的其他信息
    channel.queueDeclare("HelloWorld",true,false,false,null);

    //4. 开启监听Queue
    DefaultConsumer consume = new DefaultConsumer(channel){
        @Override
        public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
            System.out.println("接收到消息：" + new String(body,"UTF-8"));
        }
    };

    //参数1：queue - 指定消费哪个队列
    //参数2：autoAck - 指定是否自动ACK （true，接收到消息后，会立即告诉RabbitMQ,MQ就会进行删除）
    //参数3：consumer - 指定消费回调
    channel.basicConsume("HelloWorld",true,consume);

    System.out.println("消费者开始监听队列！");
    // System.in.read();
    System.in.read();

    //5. 释放资源
    channel.close();
    connection.close();
}

5.4 Work

一个生产者，一个默认的交换机，一个队列，两个消费者

结构图

只需要在消费者端，添加Qos能力以及更改为手动ack即可让消费者，根据自己的能力去消费指定的消息，而不是默认情况下由RabbitMQ平均分配了，生产者不变，正常发布消息到默认的exchange，并指定routing

消费者指定Qoa和手动ack

//1 指定当前消费者，一次消费多少个消息
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(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("消费者1号接收到消息：" + new String(body,"UTF-8"));

        //2. 手动ack
        channel.basicAck(envelope.getDeliveryTag(),false);
    }
};
//3. 指定手动ack
channel.basicConsume("Work",false,consumer);

5.5 Publish/Subscribe

一个生产者，一个交换机，两个队列，两个消费者

结构图

声明一个Fanout类型的exchange，并且将exchange和queue绑定在一起，绑定的方式就是直接绑定。

让生产者创建一个exchange并且指定类型，和一个或多个队列绑定到一起。

//3. 创建exchange - 绑定某一个队列
//参数1： exchange的名称
//参数2： 指定exchange的类型  FANOUT - pubsub ,   DIRECT - Routing , TOPIC - Topics
channel.exchangeDeclare("pubsub-exchange", BuiltinExchangeType.FANOUT);
channel.queueBind("pubsub-queue1","pubsub-exchange","");
channel.queueBind("pubsub-queue2","pubsub-exchange","");

消费者还是正常的监听某一个队列即可。

5.6 Routing

一个生产者，一个交换机，两个队列，两个消费者

结构图

生产者在创建DIRECT类型的exchange后，根据RoutingKey去绑定相应的队列，并且在发送消息时，指定消息的具体RoutingKey即可。

//3. 创建exchange, routing-queue-error,routing-queue-info,
channel.exchangeDeclare("routing-exchange", BuiltinExchangeType.DIRECT);
channel.queueBind("routing-queue-error","routing-exchange","ERROR");
channel.queueBind("routing-queue-info","routing-exchange","INFO");

//4. 发布消息到exchange，同时指定路由的规则
channel.basicPublish("routing-exchange","ERROR",null,"ERROR".getBytes());
channel.basicPublish("routing-exchange","INFO",null,"INFO1".getBytes());
channel.basicPublish("routing-exchange","INFO",null,"INFO2".getBytes());
channel.basicPublish("routing-exchange","INFO",null,"INFO3".getBytes());

消费者没有变化

5.7 Topic

一个生产者，一个交换机，两个队列，两个消费者

结构图

1）Topic模式是最常用的模式，灵活，方便，强大；
2）使用Topic模式生产者在声明队列时需要制定消息到达队列方式为topic；
3）路由键和某模式匹配，主要有两种模糊匹配：

?匹配一个或多个单词的情况，* 匹配一个单词的情况，一般使用#号匹配多个单词，*号只能匹配一个单词，用的比较少。

		// 创建交换机
		channel.exchangeDeclare("exchange_topic",BuiltinExchangeType.TOPIC);

		// 创建队列
		channel.queueDeclare("topic-emp",true,false,false,null);
		channel.queueDeclare("topic-dept",true,false,false,null);

		// 交换机绑定队列，设置路由规则
		channel.queueBind("topic-emp","exchange_topic","emp.*");
		channel.queueBind("topic-dept","exchange_topic","*.update");
		channel.queueBind("topic-dept","exchange_topic","#.delete");

		// 发布消息
channel.basicPublish("exchange_topic","emp.add",null,"emp.add".getBytes("utf-8"));
channel.basicPublish("exchange_topic","emp.add.10",null,"emp.add.10".getBytes("utf-8"));
channel.basicPublish("exchange_topic","dept.update.10",null,"dept.update.10".getBytes("utf-8"));
channel.basicPublish("exchange_topic","20.emp.delete",null,"20.emp.delete".getBytes("utf-8"));

消费者只是监听队列，没变化。

六、RabbitMQ整合SpringBoot【`重点`】

6.1 SpringBoot整合RabbitMQ

6.1.1 创建SpringBoot工程

6.1.2 导入依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

6.1.3 编写配置文件

spring:
  rabbitmq:
    host: 192.168.199.109
    port: 5672
    username: test
    password: test
    virtual-host: /test

6.1.4 声明exchange、queue

@Configuration
public class RabbitMQConfig {
    //1. 创建exchange - topic
    @Bean
    public TopicExchange getTopicExchange(){
        return new TopicExchange("boot-topic-exchange",true,false);
    }

    //2. 创建queue
    @Bean
    public Queue getQueue(){
        return new Queue("boot-queue",true,false,false,null);
    }

    //3. 绑定在一起
    @Bean
    public Binding getBinding(TopicExchange topicExchange,Queue queue){
        return BindingBuilder.bind(queue).to(topicExchange).with("*.red.*");
    }
}

6.1.5 发布消息到RabbitMQ

@Autowired
private RabbitTemplate rabbitTemplate;

@Test
void contextLoads() {
    rabbitTemplate.convertAndSend("boot-topic-exchange","slow.red.dog","红色大狼狗！！");
}

6.1.6 创建消费者监听消息

@Component
public class Consumer {

    @RabbitListener(queues = "boot-queue")
    public void getMessage(Object message){
        System.out.println("接收到消息：" + message);
    }

}

6.2 手动Ack

执行一个任务可能需要花费几秒钟，你可能会担心如果一个消费者在执行任务过程中挂掉了。一旦RabbitMQ将消息分发给了消费者，就会从内存中删除。在这种情况下，如果正在执行任务的消费者宕机，会丢失正在处理的消息和分发给这个消费者但尚未处理的消息。

但是，我们不想丢失任何任务，如果有一个消费者挂掉了，那么我们应该将分发给它的任务交付给另一个消费者去处理。

为了确保消息不会丢失，RabbitMQ支持消息应答。消费者发送一个消息应答，告诉RabbitMQ这个消息已经接收并且处理完毕了。RabbitMQ就可以删除它了。

如果一个消费者挂掉却没有发送应答，RabbitMQ会理解为这个消息没有处理完成，然后交给另一个消费者去重新处理。这样，你就可以确认即使消费者偶尔挂掉也不会丢失任何消息了。

没有任何消息超时限制；只有当消费者挂掉时，RabbitMQ才会重新投递。即使处理一条消息会花费很长的时间。

消息应答是默认打开的。我们通过显示的设置autoAsk=true关闭这种机制。现即自动应答开，一旦我们完成任务，消费者会自动发送应答。通知RabbitMQ消息已被处理，可以从内存删除。如果消费者因宕机或链接失败等原因没有发送ACK（不同于ActiveMQ，在RabbitMQ里，消息没有过期的概念），则RabbitMQ会将消息重新发送给其他监听在队列的下一个消费者。

6.2.1 添加配置文件

spring:
  rabbitmq:
    listener:
      simple:
        acknowledge-mode: manual

6.2.2 手动ack

@RabbitListener(queues = "boot-queue")
public void getMessage(String msg, Channel channel, Message message) throws IOException {
    System.out.println("接收到消息：" + msg);
    int i = 1 / 0;
    // 手动ack
    channel.basicAck(message.getMessageProperties().getDeliveryTag(),false);
}

七、RabbitMQ的其他操作

7.1 消息的可靠性

RabbitMQ的事务：事务可以保证消息100%传递，可以通过事务的回滚去记录日志，后面定时再次发送当前消息。事务的操作，效率太低，加了事务操作后，比平时的操作效率至少要慢100倍。

RabbitMQ除了事务，还提供了Confirm的确认机制，这个效率比事务高很多。

消息传递可靠性

7.1.1 普通Confirm方式

//3.1 开启confirm
channel.confirmSelect();
//3.2 发送消息
String msg = "Hello-World！";
channel.basicPublish("","HelloWorld",null,msg.getBytes());
//3.3 判断消息发送是否成功
if(channel.waitForConfirms()){
    System.out.println("消息发送成功");
}else{
    System.out.println("发送消息失败");
}

7.1.2 批量Confirm方式。

//3.1 开启confirm
channel.confirmSelect();
//3.2 批量发送消息
for (int i = 0; i < 1000; i++) {
    String msg = "Hello-World！" + i;
    channel.basicPublish("","HelloWorld",null,msg.getBytes());
}
//3.3 确定批量操作是否成功
channel.waitForConfirmsOrDie();     // 当你发送的全部消息，有一个失败的时候，就直接全部失败 抛出异常IOException

7.1.3 异步Confirm方式。

//3.1 开启confirm
channel.confirmSelect();
//3.2 批量发送消息
for (int i = 0; i < 1000; i++) {
    String msg = "Hello-World！" + i;
    channel.basicPublish("","HelloWorld",null,msg.getBytes());
}
//3.3 开启异步回调
channel.addConfirmListener(new ConfirmListener() {

    @Override
    public void handleAck(long deliveryTag, boolean multiple) throws IOException {
        System.out.println("消息发送成功，标识：" + deliveryTag + ",是否是批量" + multiple);
    }

    @Override
    public void handleNack(long deliveryTag, boolean multiple) throws IOException {
        System.out.println("消息发送失败，标识：" + deliveryTag + ",是否是批量" + multiple);
    }
});

7.1.4 Return机制

Confirm只能保证消息到达exchange，无法保证消息可以被exchange分发到指定queue。

而且exchange是不能持久化消息的，queue是可以持久化消息。

采用Return机制来监听消息是否从exchange送到了指定的queue中

消息传递可靠性

开启Return机制，并在发送消息时，指定mandatory为true

// 开启return机制
channel.addReturnListener(new ReturnListener() {
    @Override
    public void handleReturn(int replyCode, String replyText, String exchange, String routingKey, AMQP.BasicProperties properties, byte[] body) throws IOException {
        // 当消息没有送达到queue时，才会执行。
        System.out.println(new String(body,"UTF-8") + "没有送达到Queue中！！");
    }
});

// 在发送消息时，指定mandatory参数为true
channel.basicPublish("","HelloWorld",true,null,msg.getBytes());

7.2 SpringBoot实现

7.2.1 编写配置文件

spring:
  rabbitmq:
    publisher-confirm-type: simple
    publisher-returns: true

7.2.2 开启Confirm和Return

@Component
public class PublisherConfirmAndReturnConfig implements RabbitTemplate.ConfirmCallback ,RabbitTemplate.ReturnCallback {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @PostConstruct  // init-method
    public void initMethod(){
        rabbitTemplate.setConfirmCallback(this);
        rabbitTemplate.setReturnCallback(this);
    }

    @Override
    public void confirm(CorrelationData correlationData, boolean ack, String cause) {
        if(ack){
            System.out.println("消息已经送达到Exchange");
        }else{
            System.out.println("消息没有送达到Exchange");
        }
    }

    @Override
    public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
        System.out.println("消息没有送达到Queue");
    }
}

7.3 避免消息重复消费

重复消费消息，会对非幂等行操作造成问题

重复消费消息的原因是，消费者没有给RabbitMQ一个ack

重复消费

幂等性操作：比如数据库删除，操作一次和多次效果是一样的。

非幂等性操作：比如添加，而且主键是自增的。

为了解决消息重复消费的问题，可以采用Redis，在消费者消费消息之前，现将消息的id放到Redis中，

id-0（正在执行业务）

id-1（执行业务成功）

如果ack失败，在RabbitMQ将消息交给其他的消费者时，先执行setnx，如果key已经存在，获取他的值，如果是0，当前消费者就什么都不做，如果是1，直接ack。

极端情况：第一个消费者在执行业务时，出现了死锁，在setnx的基础上，再给key设置一个生存时间。

生产者，发送消息时，指定messageId

AMQP.BasicProperties properties = new AMQP.BasicProperties().builder()
    .deliveryMode(1)     //指定消息书否需要持久化 1 - 需要持久化  2 - 不需要持久化
    .messageId(UUID.randomUUID().toString())
    .build();
String msg = "Hello-World！";
channel.basicPublish("","HelloWorld",true,properties,msg.getBytes());

消费者，在消费消息时，根据具体业务逻辑去操作redis

DefaultConsumer consume = new DefaultConsumer(channel){
    @Override
    public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
        Jedis jedis = new Jedis("192.168.199.109",6379);
        String messageId = properties.getMessageId();
        //1. setnx到Redis中，默认指定value-0
        String result = jedis.set(messageId, "0", "NX", "EX", 10);
        if(result != null && result.equalsIgnoreCase("OK")) {
            System.out.println("接收到消息：" + new String(body, "UTF-8"));
            //2. 消费成功，set messageId 1
            jedis.set(messageId,"1");
            channel.basicAck(envelope.getDeliveryTag(),false);
        }else {
            //3. 如果1中的setnx失败，获取key对应的value，如果是0，return，如果是1
            String s = jedis.get(messageId);
            if("1".equalsIgnoreCase(s)){
                channel.basicAck(envelope.getDeliveryTag(),false);
            }
        }
    }
};

7.4 SpringBoot如何实现

7.4.1 导入依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

7.4.2 编写配置文件

spring:
  redis:
    host: 192.168.199.109
    port: 6379

7.4.3 修改生产者

@Test
void contextLoads() throws IOException {
    CorrelationData messageId = new CorrelationData(UUID.randomUUID().toString());
    rabbitTemplate.convertAndSend("boot-topic-exchange","slow.red.dog","红色大狼狗！！",messageId);
    System.in.read();
}

7.4.4 修改消费者

@Autowired
private StringRedisTemplate redisTemplate;


@RabbitListener(queues = "boot-queue")
public void getMessage(String msg, Channel channel, Message message) throws IOException {
    //0. 获取MessageId
    String messageId = message.getMessageProperties().getHeader("spring_returned_message_correlation");
    //1. 设置key到Redis
    if(redisTemplate.opsForValue().setIfAbsent(messageId,"0",10, TimeUnit.SECONDS)) {
        //2. 消费消息
        System.out.println("接收到消息：" + msg);

        //3. 设置key的value为1
        redisTemplate.opsForValue().set(messageId,"1",10,TimeUnit.SECONDS);
        //4.  手动ack
        channel.basicAck(message.getMessageProperties().getDeliveryTag(),false);
    }else {
        //5. 获取Redis中的value即可 如果是1，手动ack
        if("1".equalsIgnoreCase(redisTemplate.opsForValue().get(messageId))){
            channel.basicAck(message.getMessageProperties().getDeliveryTag(),false);
        }
    }
}

八、RabbitMQ应用

8.1 客户模块

8.1.1 导入依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

8.1.2 编写配置文件

  rabbitmq:
    username: admin
    password: admin
    virtual-host: /demo
    host: 192.168.193.66
    port: 5672

8.1.3 编写配置类

@Configuration
public class RabbitMQConfig {

    @Bean
    public Queue esQueue(){
        System.out.println("RabbitMQConfig.esQueue");
        return new Queue("es_queue",true,false,false);
    }

    @Bean
    public TopicExchange esExchange(){
        return new TopicExchange("es_exchange",true,false);
    }

    @Bean
    public Binding binding(Queue esQueue,TopicExchange esExchange){
        return BindingBuilder.bind(esQueue).to(esExchange).with("emp.*");
    }
}

8.1.4 修改Controller

   @RequestMapping(value = "/addEmp")
    @ResponseBody
    public ResultEntity addEmp(Emp emp){
        boolean insert = empService.insert(emp);
        if(insert){ // 数据库插入成功后在插入es
//            HttpHeaders headers = new HttpHeaders();
//            headers.setContentType(MediaType.parseMediaType("application/json"));
//            HttpEntity<Emp> entity = new HttpEntity<>(emp,headers);
//            ResultEntity resultEntity = restTemplate.postForObject("http://localhost:8081/emp-search/empserach/addEmp", entity, ResultEntity.class);
//            System.out.println(resultEntity);

            // 加入队列
            rabbitTemplate.convertAndSend("es_exchange","emp.add",emp);

        }
        return ResponseUtils.writeResponse(insert);
    }

8.2 客户模块

8.2.1 导入依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

8.2.2 编写配置文件

spring:
  rabbitmq:
    username: admin
    password: admin
    virtual-host: /demo
    host: 192.168.193.66
    port: 5672
    listener:
      simple:
        acknowledge-mode: manual # 手动ask

8.2.3 编写配置类

@Configuration
public class RabbitMQConfig {

    @Bean
    public Queue esQueue(){
        System.out.println("RabbitMQConfig.esQueue");
        return new Queue("es_queue",true,false,false);
    }

    @Bean
    public TopicExchange esExchange(){
        return new TopicExchange("es_exchange",true,false);
    }

    @Bean
    public Binding binding(Queue esQueue,TopicExchange esExchange){
        return BindingBuilder.bind(esQueue).to(esExchange).with("emp.*");
    }
}

8.2.4 编写消费者

@Configuration
public class EsQueueListener {

    @Autowired
    private IEmpService empService;

    @RabbitListener(queues = "es_queue")
    public void esQueue(Emp emp, Channel channel, Message message) throws IOException {
        String receivedRoutingKey = message.getMessageProperties().getReceivedRoutingKey();
        boolean b = empService.addEmp(emp);
       channel.basicAck(message.getMessageProperties().getDeliveryTag(),false);
        System.out.println("消费完成：");
    }
}

以上是关于RabbitMQ的基本入门的主要内容，如果未能解决你的问题，请参考以下文章

消息中间件系列二：RabbitMQ入门（基本概念RabbitMQ的安装和运行）

RabbitMQ消息中间件快速入门

RabbitMQ 入门精+转

RabbitMQ二——RabbitMQ入门教程（简单模式）

RabbitMQ入门：Hello RabbitMQ 代码实例

RabbitMQ的基本入门

RabbitMQ的基本使用

一、引言

二、RabbitMQ介绍

三、RabbitMQ安装

四、RabbitMQ架构【重点】

4.1 官方的简单架构图

4.2 RabbitMQ的完整架构图

4.3 查看图形化界面并创建一个Virtual Host

五、RabbitMQ的使用【重点】

5.1 RabbitMQ的通讯方式

5.2 Java连接RabbitMQ

5.2.1 创建maven项目

5.2.2 导入依赖

5.2.3 创建工具类连接RabbitMQ

5.2.4 测试连接

5.3 Hello-World

5.4 Work

5.5 Publish/Subscribe

5.6 Routing

5.7 Topic

六、RabbitMQ整合SpringBoot【重点】

6.1 SpringBoot整合RabbitMQ

6.1.1 创建SpringBoot工程

6.1.2 导入依赖

6.1.3 编写配置文件

6.1.4 声明exchange、queue

6.1.5 发布消息到RabbitMQ

6.1.6 创建消费者监听消息

6.2 手动Ack

6.2.1 添加配置文件

6.2.2 手动ack

七、RabbitMQ的其他操作

7.1 消息的可靠性

7.1.1 普通Confirm方式

7.1.2 批量Confirm方式。

7.1.3 异步Confirm方式。

7.1.4 Return机制

7.2 SpringBoot实现

7.2.1 编写配置文件

7.2.2 开启Confirm和Return

7.3 避免消息重复消费

7.4 SpringBoot如何实现

7.4.1 导入依赖

7.4.2 编写配置文件

7.4.3 修改生产者

7.4.4 修改消费者

八、RabbitMQ应用

8.1 客户模块

8.1.1 导入依赖

8.1.2 编写配置文件

8.1.3 编写配置类

8.1.4 修改Controller

8.2 客户模块

8.2.1 导入依赖

8.2.2 编写配置文件

8.2.3 编写配置类

8.2.4 编写消费者

四、RabbitMQ架构【`重点`】

五、RabbitMQ的使用【`重点`】

六、RabbitMQ整合SpringBoot【`重点`】