RabbitMQ快速入门和使用

消息队列的基本概述

安装RabbitMQ

编写RabbitMQ的入门程序

RabbitMQ的5种模式特征

SpringBoot整合RabbitMQ

消息队列的基本概述

消息队列是应用程序之间的通信方法；无需即时返回的且耗时的操作进行异步处理从而提高系统的吞吐量；可以实现程序之间的解耦合。
实现方式：AMQP，JMS
常见产品：activeMQ，zeroMQ，RabbitMQ，RocketMQ，kafka

安装RabbitMQ

安装erlang
安装rabbitMQ
安装RabbitMQ的图形管理界面插件
创建管理用户
创建虚拟主机Virtual Hosts

编写RabbitMQ的入门程序

入门工程

目标:

创建heima-rabbitmq的工程；用于测试RabbitMQ的消息收发。添加用于操作RabbitMQ的依赖。

搭建RabbitMQ入门工程并配置对应的maven依赖

 dependency> com.rabbitmq
        amqp-client
        5.6.0

入门工程-生产者

创建工厂(设置RabbitMQ的连接参数)
创建连接
创建频道
声明对列
发送消息
关闭资源

代码实现

在设置连接工厂的时候；如果没有指定连接的参数则会有默认值；可以去设置虚拟主机。

public class Producer {


    static final String QUEUE_NAME = "simple_queue";

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

        //1. 创建工厂(设置RabbitMQ的连接参数)
        ConnectionFactory connFactory = new ConnectionFactory();
        //主机 默认:localhost
        connFactory.setHost("localhost");
        //连接端口
        connFactory.setPort(5672);
        //虚拟主机 默认/
        connFactory.setVirtualHost("/itcast");
        //用户名 默认 guest
        connFactory.setUsername("guest");
        //密码 默认 guest
        connFactory.setPassword("guest");


        //2. 创建连接
        Connection connection = connFactory.newConnection();


        //3. 创建频道
        Channel channel = connection.createChannel();

        //4. 声明对列
        
        channel.queueDeclare(QUEUE_NAME, true, false, false, null);


        //5. 传递消息
        String mess = "hello!";
        
        channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
        System.out.println("已发送消息：" + mess);

        //6. 关闭资源
        channel.close();
        connection.close();
    }

}

入门工程-消费者

public class Consumer  {
    public static void main(String[] args) throws Exception {
        //1. 创建连接工厂；
        //2. 创建连接；（抽取一个获取连接的工具类）
        Connection connection = ConnectionUtil.getConnection();
        //3. 创建频道；
        Channel channel = connection.createChannel();
        //4. 声明队列；
        
        channel.queueDeclare(Producer.QUEUE_NAME, true, false, false, null);
        //5. 创建消费者（接收消息并处理消息）；
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //路由key
                System.out.println("路由key为：" + envelope.getRoutingKey());
                //交换机
                System.out.println("交换机为：" + envelope.getExchange());
                //消息id
                System.out.println("消息id为：" + envelope.getDeliveryTag());
                //接收到的消息
                System.out.println("接收到的消息为：" + new String(body, "utf-8"));
            }
        };
        //6. 监听队列
        
        channel.basicConsume(Producer.QUEUE_NAME, true, defaultConsumer);

    }
}

RabbitMQ的5种模式特征

Work queues工作对列模式

模式说明

工作队列模式：在同一个队列中可以有多个消费者，消费者之间对于消息的接收是竞争关系。

应用场景：可以在消费者端处理任务比较耗时的时候；添加对同一个队列的消费者来提高任务处理能力。

代码实现

生产者

public class Producer {
    static final String QUEUE_NAME = "work_queue";

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

        Connection connection = ConnectionUtil.getConnection();


        //3. 创建频道
        Channel channel = connection.createChannel();

        //4. 声明对列
        
        channel.queueDeclare(QUEUE_NAME, true, false, false, null);


        //5. 传递消息
        for (int i = 1; i <= 30; i++) {
            String mess = "hello!" + i;
        
            channel.basicPublish("", QUEUE_NAME, null, mess.getBytes());
            System.out.println("已发送消息：" + mess);
        }
        //6. 关闭资源
        channel.close();
        connection.close();
    }
}

消费者

public class Consumer1 {
    public static void main(String[] args) throws Exception {
        //1. 创建连接工厂；
        //2. 创建连接；（抽取一个获取连接的工具类）
        Connection connection = ConnectionUtil.getConnection();
        //3. 创建频道；
        Channel channel = connection.createChannel();
        //4. 声明队列；
        
        channel.queueDeclare(Producer.QUEUE_NAME, true, false, false, null);

        //一次只能接收并处理一个消息
        channel.basicQos(1);

        //5. 创建消费者（接收消息并处理消息）；
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //路由key
                System.out.println("路由key为：" + envelope.getRoutingKey());
                //交换机
                System.out.println("交换机为：" + envelope.getExchange());
                //消息id
                System.out.println("消息id为：" + envelope.getDeliveryTag());
                //接收到的消息
                System.out.println("1接收到的消息为：" + new String(body, "utf-8"));
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        //6. 监听队列
        
        channel.basicConsume(Producer.QUEUE_NAME, true, defaultConsumer);

    }
}

订阅模式类型
基本说明:

说出订阅模式中的Exchange交换机作用以及交换机的三种类型

订阅模式与前面的两种模式比较：多了一个角色Exchange交换机，接收生产者发送的消息并决定如何投递消息到其绑定的队列；消息的投递决定于交换机的类型。
交换机类型：广播（fanout）、定向（direct）、通配符（topic）

交换机只做消息转发，自身不存储数据

PS发布与订阅模式

简要说明:

发布与订阅模式特点：一个消息可以被多个消费者接收；其实是使用了订阅模式，交换机类型为：fanout广播

基本思路:

生产者

创建连接
创建频道
声明交换机（fanout）
声明队列
队列绑定到交换机
发送消息
关闭资源

消费者（至少两个消费者）

创建连接
创建频道
声明交换机
声明队列
队列绑定到交换机
创建消费者
监听队列

代码实现:

生产者:

public class Producer {


    //交换机名称
    static final String FANOUT_EXCHANGE = "fanout_exchange";
    //队列名称
    static final String FANOUT_QUEUE_1 = "fanout_queue_1";
    //队列名称
    static final String FANOUT_QUEUE_2 = "fanout_queue_2";

    public static void main(String[] args) throws Exception {
        //1. 创建连接；
        Connection connection = ConnectionUtil.getConnection();
        //2. 创建频道；
        Channel channel = connection.createChannel();
        //3. 声明交换机；参数1：交换机名称，参数2：交换机类型（fanout,direct,topic）
        channel.exchangeDeclare(FANOUT_EXCHANGE, BuiltinExchangeType.FANOUT);
        //4. 声明队列；
        
        channel.queueDeclare(FANOUT_QUEUE_1, true, false, false, null);
        channel.queueDeclare(FANOUT_QUEUE_2, true, false, false, null);

        //5. 队列绑定到交换机；参数1：队列名称，参数2：交换机名称，参数3：路由key
        channel.queueBind(FANOUT_QUEUE_1, FANOUT_EXCHANGE, "");
        channel.queueBind(FANOUT_QUEUE_2, FANOUT_EXCHANGE, "");

        //6. 发送消息；
        for(int i = 1; i<=10; i++) {
            String message = "你好！小兔纸。发布订阅模式 --- " + i;

            
            channel.basicPublish(FANOUT_EXCHANGE, "", null, message.getBytes());
            System.out.println("已发送消息：" + message);
        }
        //6. 关闭资源
        channel.close();
        connection.close();
    }

}

消费者:

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

            //1. 创建连接；（抽取一个获取连接的工具类）
            Connection connection = ConnectionUtil.getConnection();
            //2. 创建频道；
            Channel channel = connection.createChannel();
            //3. 声明交换机
            channel.exchangeDeclare(Producer.FANOUT_EXCHANGE, BuiltinExchangeType.FANOUT);

            //4. 声明队列；
            
            channel.queueDeclare(Producer.FANOUT_QUEUE_1, true, false, false, null);

            //5. 队列绑定到交换机上
            channel.queueBind(Producer.FANOUT_QUEUE_1, Producer.FANOUT_EXCHANGE, "");

            //6. 创建消费者（接收消息并处理消息）；
            DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                    //路由key
                    System.out.println("路由key为：" + envelope.getRoutingKey());
                    //交换机
                    System.out.println("交换机为：" + envelope.getExchange());
                    //消息id
                    System.out.println("消息id为：" + envelope.getDeliveryTag());
                    //接收到的消息
                    System.out.println("消费者1 --- 接收到的消息为：" + new String(body, "utf-8"));
                }
            };
            //6. 监听队列
            
            channel.basicConsume(Producer.FANOUT_QUEUE_1, true, defaultConsumer);
        }
}

Routing路由模式

路由模式特点：

队列与交换机的绑定，不能是任意绑定了，而是要指定一个 RoutingKey （路由key）
消息的发送方在向 Exchange发送消息时，也必须指定消息的 RoutingKey 。
Exchange不再把消息交给每一个绑定的队列，而是根据消息的 Routing Key 进行判断，只有队列的

Routingkey 与消息的 Routing key 完全一致，才会接收到消息

图解：

P：生产者，向Exchange发送消息，发送消息时，会指定一个routing key。

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

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

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

代码实现:

Routing 路面模式要求队列绑定到交换机的时候指定路由key；消费发送时候需要携带路由key；只有消息的路由key与队列路由key完全一致才能让该队列接收到消息。

生产方:

public class Producer {
    //交换机名称
    static final String DIRECT_EXCHANGE = "direct_exchange";
    //队列名称
    static final String DIRECT_QUEUE_INSERT = "direct_queue_insert";
    //队列名称
    static final String DIRECT_QUEUE_UPDATE = "direct_queue_update";

    public static void main(String[] args) throws Exception {
        //1. 创建连接；
        Connection connection = ConnectionUtil.getConnection();
        //2. 创建频道；
        Channel channel = connection.createChannel();
        //3. 声明交换机；参数1：交换机名称，参数2：交换机类型（fanout,direct,topic）
        channel.exchangeDeclare(DIRECT_EXCHANGE, BuiltinExchangeType.DIRECT);
        //4. 声明队列；
        
        channel.queueDeclare(DIRECT_QUEUE_INSERT, true, false, false, null);
        channel.queueDeclare(DIRECT_QUEUE_UPDATE, true, false, false, null);

        //5. 队列绑定到交换机；参数1：队列名称，参数2：交换机名称，参数3：路由key
        channel.queueBind(DIRECT_QUEUE_INSERT, DIRECT_EXCHANGE, "insert");
        channel.queueBind(DIRECT_QUEUE_UPDATE, DIRECT_EXCHANGE, "update");

        //6. 发送消息；
        String message = "你好！小兔纸。路由模式 ；routing key 为 insert ";

        
        channel.basicPublish(DIRECT_EXCHANGE, "insert", null, message.getBytes());
        System.out.println("已发送消息：" + message);

        message = "你好！小兔纸。路由模式 ；routing key 为 update ";

        
        channel.basicPublish(DIRECT_EXCHANGE, "update", null, message.getBytes());
        System.out.println("已发送消息：" + message);
        //6. 关闭资源
        channel.close();
        connection.close();
    }
}

消费方:

public class Consumer1 {
    public static void main(String[] args) throws Exception {
        //1. 创建连接；（抽取一个获取连接的工具类）
        Connection connection = ConnectionUtil.getConnection();
        //2. 创建频道；
        Channel channel = connection.createChannel();
        //3. 声明交换机
        channel.exchangeDeclare(Producer.DIRECT_EXCHANGE, BuiltinExchangeType.DIRECT);

        //4. 声明队列；
        
        channel.queueDeclare(Producer.DIRECT_QUEUE_INSERT, true, false, false, null);

        //5. 队列绑定到交换机上
        channel.queueBind(Producer.DIRECT_QUEUE_INSERT, Producer.DIRECT_EXCHANGE, "insert");

        //6. 创建消费者（接收消息并处理消息）；
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //路由key
                System.out.println("路由key为：" + envelope.getRoutingKey());
                //交换机
                System.out.println("交换机为：" + envelope.getExchange());
                //消息id
                System.out.println("消息id为：" + envelope.getDeliveryTag());
                //接收到的消息
                System.out.println("消费者1 --- 接收到的消息为：" + new String(body, "utf-8"));
            }
        };
        //6. 监听队列
        
        channel.basicConsume(Producer.DIRECT_QUEUE_INSERT, true, defaultConsumer);
    }
}

Topice通配符模式

基本说明:

Topic 类型与 Direct 相比，都是可以根据 RoutingKey 把消息路由到不同的队列。只不过 Topic 类型 Exchange 可以让队列在绑定 Routing key 的时候使用通配符！
Routingkey 一般都是有一个或多个单词组成，多个单词之间以”.”分割，例如： item.insert

通配符规则：

# ：匹配一个或多个词

* ：匹配不多不少恰好1个词

举例：

item.# ：能够匹配 item.insert.abc 或者 item.insert

item.* ：只能匹配 item.insert

总结
不直接Exchange交换机（默认交换机）

simple简单模式：一个生产者生产一个消息到一个队列被一个消费者接收
work工作队列模式：生产者发送消息到一个队列中，然后可以被多个消费者监听该队列；一个消息只能被一个消费者接收，消费者之间是竞争关系

使用Exchange交换机；订阅模式（交换机：广播fanout、定向direct、通配符topic）

发布与订阅模式：使用了fanout广播类型的交换机，可以将一个消息发送到所有绑定了该交换机的队列
路由模式：使用了direct定向类型的交换机，消费会携带路由key，交换机根据消息的路由key与队列的路由key进行对比，一致的话那么该队列可以接收到消息
通配符模式：使用了topic通配符类型的交换机，消费会携带路由key（*， #），交换机根据消息的路由key与队列的路由key进行对比，匹配的话那么该队列可以接收到消息

SpringBoot整合RabbitMQ

基本总思路:
创建springboot-rabbitmq-producer工程用于生产消息,

创建springboot-rabbitmq-consumer工程用于接收消息

Spring Boot提供了对于AMQP的整合；可以使用RabbitTemplate发送消息；可以使用@RabbitListener注解接收消息。

创建工程；
添加依赖（spring-boot-stater-amqp，spring-boot-starter-test）；
创建启动引导类；
添加配置文件application.yml

配置生产者工程

基本思路:

配置RabbitMQ的连接参数：主机、连接端口、虚拟主机、用户名、密码
声明交换机、队列并将队列绑定到交换机，指定的路由key（item.#）

代码实现

依赖

 
        org.springframework.boot
        spring-boot-starter-parent
        2.1.4.RELEASE
    

    com.itheima
    springboot-rabbitmq-consumer
    1.0-SNAPSHOT

    
    
        
            org.springframework.boot
            spring-boot-starter-amqp
        

    
        org.springframework.boot
        spring-boot-starter-test

配置RabbitMQ的连接参数：主机、连接端口、虚拟主机、用户名、密码

spring:
  rabbitmq:
    host: localhost
    port: 5672
    virtual-host: /itcast
    username: admin
    password: 123456

声明交换机、队列并将队列绑定到交换机，指定的路由key（item.#）

@Configuration
public class RabbitMQConfig  {


    //交换机名称
    public static final String ITEM_TOPIC_EXCHANGE = "item_topic_exchange";

    //队列名称
    public static final String ITEM_QUEUE = "item_queue";

    //声明交换机
    @Bean("itemTopicExchange")
    public Exchange topicExchange(){
        return ExchangeBuilder.topicExchange(ITEM_TOPIC_EXCHANGE).durable(true).build();
    }

    //声明队列
    @Bean("itemQueue")
    public Queue itemQueue(){
        return QueueBuilder.durable(ITEM_QUEUE).build();
    }

    //将队列绑定到交换机
    @Bean
    public Binding itemQueueExchange(@Qualifier("itemQueue") Queue queue,
                                     @Qualifier("itemTopicExchange")Exchange exchange){
        return BindingBuilder.bind(queue).to(exchange).with("item.#").noargs();
    }



}

配置消费者工程 :

基本思路:

配置application.yml文件，设置RabbitMQ的连接参数；
编写消息监听器接收队列（item_queue）消息；可以使用注解@RabbitListener接收队列消息

代码实现:

依赖


        org.springframework.boot
        spring-boot-starter-parent
        2.1.4.RELEASE
    

    com.itheima
    springboot-rabbitmq-consumer
    1.0-SNAPSHOT

    
        
            org.springframework.boot
            spring-boot-starter-amqp

配置application.yml文件，设置RabbitMQ的连接参数；

spring:
  rabbitmq:
    host: localhost
    port: 5672
    virtual-host: /itcast
    username: admin
    password: 123456

编写消息监听器接收队列（item_queue）消息；可以使用注解@RabbitListener接收队列消息

@Component
public class MyListener {
    
    @RabbitListener(queues = "item_queue")
    public void myListener1(String message){
        System.out.println("接收到的消息:"+message);
    }

}

测试消息发送和接收

目标:
生产者编写测试类RabbitMQTest发送消息到交换机和特定的路由（item.insert，item.update，item.delete）

基本思路:
生产者：编写测试类RabbitMQTest，利用RabbitTemplate发送3条消息，这3条消息的路由key分别是item.insert，item.update，item.delete
消费者：在IDEA控制台查看是否能接收到符合路由key的消息

代码实现:

先启动测试类进行声明交换机、队列和绑定；之后再启动消费者工程接收消息。

@RunWith(SpringRunner.class)
@SpringBootTest
public class RabbitMQTest {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void test(){
        rabbitTemplate.convertAndSend(RabbitMQConfig.ITEM_TOPIC_EXCHANGE,
                "item.insert", "商品新增,路由Key为item.insert");
        rabbitTemplate.convertAndSend(RabbitMQConfig.ITEM_TOPIC_EXCHANGE,
                "item.update", "商品新增,路由Key为item.update");
        rabbitTemplate.convertAndSend(RabbitMQConfig.ITEM_TOPIC_EXCHANGE,
                "item.delete", "商品新增,路由Key为item.delete");
        rabbitTemplate.convertAndSend(RabbitMQConfig.ITEM_TOPIC_EXCHANGE,
                "a.item.delete", "商品新增,路由Key为a.item.delete");
    }
}

RabbitMQ快速入门和使用

消息队列的基本概述 消息队列是应用程序之间的通信方法；无需即时返回的且耗时的操作进行异步处理从而提高系统的吞吐量；可以实现程序之间的解耦合。实现方式：AMQP，JMS常见产品：activeMQ，zeroMQ，RabbitMQ，RocketMQ，kafka

安装RabbitMQ 安装erlang安装rabbitMQ安装RabbitMQ的图形管理界面插件创建管理用户创建虚拟主机Virtual Hosts

编写RabbitMQ的入门程序

入门工程

目标: 创建heima-rabbitmq的工程；用于测试RabbitMQ的消息收发。添加用于操作RabbitMQ的依赖。 搭建RabbitMQ入门工程并配置对应的maven依赖 dependency> com.rabbitmq amqp-client 5.6.0

RabbitMQ的5种模式特征

SpringBoot整合RabbitMQ

测试消息发送和接收

目标: 生产者编写测试类RabbitMQTest发送消息到交换机和特定的路由（item.insert，item.update，item.delete）

基本思路: 生产者：编写测试类RabbitMQTest，利用RabbitTemplate发送3条消息，这3条消息的路由key分别是item.insert，item.update，item.delete消费者：在IDEA控制台查看是否能接收到符合路由key的消息

Java相关栏目本月热门文章

消息队列的基本概述

消息队列是应用程序之间的通信方法；无需即时返回的且耗时的操作进行异步处理从而提高系统的吞吐量；可以实现程序之间的解耦合。
实现方式：AMQP，JMS
常见产品：activeMQ，zeroMQ，RabbitMQ，RocketMQ，kafka

安装RabbitMQ

安装erlang
安装rabbitMQ
安装RabbitMQ的图形管理界面插件
创建管理用户
创建虚拟主机Virtual Hosts

目标:
创建heima-rabbitmq的工程；用于测试RabbitMQ的消息收发。添加用于操作RabbitMQ的依赖。

搭建RabbitMQ入门工程并配置对应的maven依赖

dependency> com.rabbitmq amqp-client 5.6.0

目标:
生产者编写测试类RabbitMQTest发送消息到交换机和特定的路由（item.insert，item.update，item.delete）

基本思路:
生产者：编写测试类RabbitMQTest，利用RabbitTemplate发送3条消息，这3条消息的路由key分别是item.insert，item.update，item.delete
消费者：在IDEA控制台查看是否能接收到符合路由key的消息