rabbitmq基本使用和springboot整合

最新推荐文章于 2024-08-12 00:09:38 发布

遇见我是你的荣幸

最新推荐文章于 2024-08-12 00:09:38 发布

阅读量242

点赞数

分类专栏： Java

本文链接：https://blog.csdn.net/u010689849/article/details/115281140

版权

Java 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

1.mq简介

MQ全称为Message Queue，消息队列是应用程序和应用程序之间的通信方法。在项目中，可将一些无需即时返回且耗时的操作提取出来，进行异步处理，而这种异步处理的方式大大的节省了服务器的请求响应时间，从而提高了系统的吞吐量。

应用场景：

1、任务异步处理

将不需要同步处理的并且耗时长的操作由消息队列通知消息接收方进行异步处理。提高了应用程序的响应时间。

2.应用程序解耦合

MQ相当于一个中介，生产方通过MQ与消费方交互，它将应用程序进行解耦合。例如大数据处理中，主要项目为Java编写，而数据处理为python,则可以通过mq将任务发给python进行处理。

3、削峰填谷

如订单系统，在下单的时候就会往数据库写数据。但是数据库只能支撑每秒1000左右的并发写入，并发量再高就容易宕机。低峰期的时候并发也就100多个，但是在高峰期时候，并发量会突然激增到5000以上，这个时候数据库肯定卡死了。

消息被MQ保存起来了，然后系统就可以按照自己的消费能力来消费，比如每秒1000个数据，这样慢慢写入数据库，这样就不会卡死数据库了。

但是使用了MQ之后，限制消费消息的速度为1000，但是这样一来，高峰期产生的数据势必会被积压在MQ中，高峰就被“削”掉了。但是因为消息积压，在高峰期过后的一段时间内，消费消息的速度还是会维持在1000QPS，直到消费完积压的消息,这就叫做“填谷”

实现MQ的大致有两种主流方式

MQ是消息通信的模型；实现MQ的大致有两种主流方式：AMQP、JMS。

AMQP

AMQP是一种协议，更准确的说是一种binary wire-level protocol（链接协议）。这是其和JMS的本质差别，AMQP不从API层进行限定，而是直接定义网络交换的数据格式。

JMS

JMS即Java消息服务（JavaMessage Service）应用程序接口，是一个Java平台中关于面向消息中间件（MOM）的API，用于在两个应用程序之间，或分布式系统中发送消息，进行异步通信。

AMQP 与 JMS 区别：

JMS是定义了统一的接口，来对消息操作进行统一；AMQP是通过规定协议来统一数据交互的格式
JMS限定了必须使用Java语言；AMQP只是协议，不规定实现方式，因此是跨语言的。
JMS规定了两种消息模式；而AMQP的消息模式更加丰富

2.入门示例

1.创建maven工程添加依赖

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

2.编写生产者

public class Producer {

    static final String QUEUE_NAME = "simple_queue";

    public static void main(String[] args) throws IOException, TimeoutException {
        //创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();

        //主机地址;默认为 localhost
        connectionFactory.setHost("192.168.94.134");

        //连接端口;默认为 5672
        connectionFactory.setPort(5672);

        //虚拟主机名称;默认为 /
        connectionFactory.setVirtualHost("/cz");

        //连接用户名；默认为guest
        connectionFactory.setUsername("admin");
        //连接密码；默认为guest
        connectionFactory.setPassword("123456");

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

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

        // 声明（创建）队列
        /**
         * 参数1：队列名称
         * 参数2：是否定义持久化队列
         * 参数3：是否独占本次连接
         * 参数4：是否在不使用的时候自动删除队列
         * 参数5：队列其它参数
         */
        channel.queueDeclare(QUEUE_NAME, true, false, false, null);

        // 要发送的信息
        String message = "helloWorld";
        /**
         * 参数1：交换机名称，如果没有指定则使用默认Default Exchage
         * 参数2：路由key,简单模式可以传递队列名称
         * 参数3：消息其它属性
         * 参数4：消息内容
         */
        channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
        System.out.println("已发送消息：" + message);

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

运行后查看界面：

如果没有channel.close(); connection.close();这两行代码，可以看到channel和connection的信息.

3.编写消费者

public class Consumer {

    private static final String QUEUE_NAME = "simple_queue";

    public static void main(String[] args) throws IOException, TimeoutException {
        //创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();

        //主机地址;默认为 localhost
        connectionFactory.setHost("192.168.94.134");

        //连接端口;默认为 5672
        connectionFactory.setPort(5672);

        //虚拟主机名称;默认为 /
        connectionFactory.setVirtualHost("/cz");

        //连接用户名；默认为guest
        connectionFactory.setUsername("admin");
        //连接密码；默认为guest
        connectionFactory.setPassword("123456");

        Connection connection = connectionFactory.newConnection();

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

        // 声明（创建）队列
        /**
         * 参数1：队列名称
         * 参数2：是否定义持久化队列
         * 参数3：是否独占本次连接
         * 参数4：是否在不使用的时候自动删除队列
         * 参数5：队列其它参数
         */
        channel.queueDeclare(QUEUE_NAME, true, false, false, null);

        //创建消费者；并设置消息处理
        DefaultConsumer consumer = new DefaultConsumer(channel){
            @Override
            /**回调方法
             * consumerTag 消息者标签，在channel.basicConsume时候可以指定
             * envelope 消息包的内容，可从中获取消息id，消息routingkey，交换机，消息和重传标志(收到消息失败后是否需要重新发送)
             * properties 属性信息
             * body 消息
             */
            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"));
            }
        };
        //监听消息
        /**
         * 参数1：队列名称
         * 参数2：是否自动确认，设置为true为表示消息接收到自动向mq回复接收到了，mq接收到回复会删除消息，设置为false则需要手动确认
         * 参数3：消息接收到后回调
         */
        channel.basicConsume(QUEUE_NAME, true, consumer);

        //不关闭资源，应该一直监听消息
        //channel.close();
        //connection.close();
    }
}

生产者，也就是要发送消息的程序

消费者：消息的接受者，会一直等待消息到来。

3.工作模式

1.简单模式

上述案例为简单模式，简单模式中能有一个生产者，一个消费者

2.Work queues工作队列模式

work queues与入门程序的简单模式的代码是几乎一样的；可以完全复制，并复制多一个消费者进行多个消费者同时消费消息的测试。而多个消费者是竞争关系，但是一个消息只能被消费一次。

3.订阅模式

对于简单模式和工作模式都只有生产者和消费者两个角色，但订阅模式多了一个exchange角色，而且过程略有变化：

P：生产者，也就是要发送消息的程序，但是不再发送到队列中，而是发给X（交换机）
C：消费者，消息的接受者，会一直等待消息到来。
Queue：消息队列，接收消息、缓存消息。
Exchange：交换机，图中的X。一方面，接收生产者发送的消息。另一方面，知道如何处理消息，例如递交给某个特别队列、递交给所有队列、或是将消息丢弃。到底如何操作，取决于Exchange的类型。Exchange有常见以下3种类型：

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

Direct：定向，把消息交给符合指定routing key 的队列

Topic：通配符，把消息交给符合routing pattern（路由模式）的队列

Exchange（交换机）只负责转发消息，不具备存储消息的能力，因此如果没有任何队列与Exchange绑定，或者没有符合路由规则的队列，那么消息会丢失！

模式说明

发布订阅模式： 1、每个消费者监听自己的队列。

2、生产者将消息发给broker，由交换机将消息转发到绑定此交换机的每个队列，每个绑定交换机的队列都将接收到消息

生产者：

private static final String FANOUT_EXCHAGE = "fanout_exchange";
    //队列名称
    private static final String FANOUT_QUEUE_1 = "fanout_queue_1";
    //队列名称
    private static final String FANOUT_QUEUE_2 = "fanout_queue_2";

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

        //主机地址;默认为 localhost
        connectionFactory.setHost("192.168.94.134");

        //连接端口;默认为 5672
        connectionFactory.setPort(5672);

        //虚拟主机名称;默认为 /
        connectionFactory.setVirtualHost("/cz");

        //连接用户名；默认为guest
        connectionFactory.setUsername("admin");
        //连接密码；默认为guest
        connectionFactory.setPassword("123456");

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

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

        //申明交换机
        /**
         * 参数1：交换机名称，如果没有指定则使用默认Default Exchage
         * 参数2：交换机类型：DIRECT("direct"), FANOUT("fanout"), TOPIC("topic"), HEADERS("headers")
         * 参数3：是否持久化
         * 参数4：自动删除
         * 参数5：内部使用
         * 参数6：参数
         */
        channel.exchangeDeclare(FANOUT_EXCHAGE, BuiltinExchangeType.FANOUT, true, false, false, null);
        //创建队列
        channel.queueDeclare(FANOUT_QUEUE_1, true, false, false, null);
        channel.queueDeclare(FANOUT_QUEUE_2, true, false, false, null);

        //绑定交换机
        /**
         * queue：队列名称
         * exchange：交换机名称
         * routingKey：路由链，绑定规则，如果交换机类型为FANOUT，设置为""
         */
        channel.queueBind(FANOUT_QUEUE_1, FANOUT_EXCHAGE, "");
        channel.queueBind(FANOUT_QUEUE_2, FANOUT_EXCHAGE, "");

编写上面代码后执行可以看到界面：

点击可以看到交换机和队列的绑定关系：

/**
         * 参数1：交换机名称，如果没有指定则使用默认Default Exchage
         * 参数2：路由key,简单模式可以传递队列名称
         * 参数3：消息其它属性
         * 参数4：消息内容
         */
        String message = "订阅模式消息发送";
        channel.basicPublish(FANOUT_EXCHAGE, "", null, message.getBytes());

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

消费者：

消费者代码一样，只需指明消费者对应的队列名称

//和生产者一样
channel.exchangeDeclare(FANOUT_EXCHAGE, BuiltinExchangeType.FANOUT, true, false, false, null);
        //申明队列和也和生产者一样，这里关联队列1
        channel.queueDeclare(FANOUT_QUEUE_1, true, false, false, null);

        //队列绑定交换机
        channel.queueBind(FANOUT_QUEUE_1, FANOUT_EXCHAGE, "");

        //创建消费者；并设置消息处理
        DefaultConsumer consumer = new DefaultConsumer(channel){
            @Override
            /**
             * consumerTag 消息者标签，在channel.basicConsume时候可以指定
             * envelope 消息包的内容，可从中获取消息id，消息routingkey，交换机，消息和重传标志(收到消息失败后是否需要重新发送)
             * properties 属性信息
             * body 消息
             */
            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"));
            }
        };
        //监听消息
        /**
         * 参数1：队列名称
         * 参数2：是否自动确认，设置为true为表示消息接收到自动向mq回复接收到了，mq接收到回复会删除消息，设置为false则需要手动确认
         * 参数3：消息接收到后回调
         */
        channel.basicConsume(FANOUT_QUEUE_1, true, consumer);

发布订阅模式与工作队列模式的区别

1、工作队列模式不用定义交换机，而发布/订阅模式需要定义交换机。

2、发布/订阅模式的生产方是面向交换机发送消息，工作队列模式的生产方是面向队列发送消息(底层使用默认交换机)。

3、发布/订阅模式需要设置队列和交换机的绑定，工作队列模式不需要设置，实际上工作队列模式会将队列绑定到默认的交换机。

4.路由模式

模式说明

队列与交换机的绑定，不能是任意绑定了，而是要指定一个 Routingkey(路由)
消息的发送方在向 Exchange发送消息时，也必须指定消息的 Routingkey
Exchange不再把消息交给每一个绑定的队列，而是根据消息的 Routingkey进行判断，只有队列的Routingkey与消息的Routingkey完全一致，才会接收到消息

P：生产者，向Exchange发送消息，发送消息时，会指定一个routing key。
X：Exchange（交换机），接收生产者的消息，然后把消息递交给与routing key完全匹配的队列
C1：消费者，其所在队列指定了需要routing key 为 error 的消息
C2：消费者，其所在队列指定了需要routing key 为 info、error、warning 的消息

对于创建Connection，Channel和创建队列等订阅模式一样。

申明交换机中需指定交换机类型为DIRECT

channel.exchangeDeclare(DIRECT_EXCHAGE, BuiltinExchangeType.DIRECT, true, false, false, null);

路由模式中指定路由绑定规则

//绑定交换机
/**
 * queue：队列名称
 * exchange：交换机名称
 * routingKey：路由链，绑定规则，如果交换机类型为FANOUT，设置为""
 */
channel.queueBind(DIRECT_QUEUE_1, DIRECT_EXCHAGE, "error");
//队列2绑定info，error，warning
channel.queueBind(DIRECT_QUEUE_2, DIRECT_EXCHAGE, "info");
channel.queueBind(DIRECT_QUEUE_2, DIRECT_EXCHAGE, "error");
channel.queueBind(DIRECT_QUEUE_2, DIRECT_EXCHAGE, "warning");

发送消息时，也许指定路由规则

        /**
         * 参数1：交换机名称，如果没有指定则使用默认Default Exchage
         * 参数2：路由key,简单模式可以传递队列名称
         * 参数3：消息其它属性
         * 参数4：消息内容
         */
        String message = "路由模式消息发送，error储存数据库，info打印控制台";
        channel.basicPublish(DIRECT_EXCHAGE, "info", null, message.getBytes());

运行后可以看到消息发往DIRECT_QUEUE_2。

对于消费者Connection，Channel，Exchange和生产者一样需指定交换机类型为DIRECT。

对于路由模式使用场景，可以以不同逻辑指定需发送的队列让消费者处理不同也业务。

5.Topics通配符模式

模式说明

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

通配规则：

#：匹配一个或多个词。

*：有且只匹配一个词

例如：xxxx.#可以匹配xxxx.123或xxxx.123.qwe；而xxxx.*只能匹配xxxx.123

生产者：

交换机需声明为BuiltinExchangeType.TOPIC

channel.exchangeDeclare(TOPIC_EXCHAGE, BuiltinExchangeType.TOPIC, true, false, false, null);

//创建队列
channel.queueDeclare(TOPIC_QUEUE_1, true, false, false, null);
channel.queueDeclare(TOPIC_QUEUE_2, true, false, false, null);

channel.queueBind(TOPIC_QUEUE_1, TOPIC_EXCHAGE, "opt.#");

channel.queueBind(TOPIC_QUEUE_2, TOPIC_EXCHAGE, "opt.update.*");
channel.queueBind(TOPIC_QUEUE_2, TOPIC_EXCHAGE, "opt.*");

channel.basicPublish(TOPIC_EXCHAGE, "opt.update", null, "opt.update".getBytes());
channel.basicPublish(TOPIC_EXCHAGE, "opt.update.1111", null, "opt.update.1111".getBytes());
channel.basicPublish(TOPIC_EXCHAGE, "opt.update.1111.2222", null, "opt.update.1111.2222".getBytes());

运行后可以看到绑定结果：

队列信息：

消费者：

        channel.queueDeclare(TOPIC_QUEUE_1, true, false, false, null);

        //创建消费者；并设置消息处理
        DefaultConsumer consumer = new DefaultConsumer(channel){
            @Override
            /**回调方法
             * consumerTag 消息者标签，在channel.basicConsume时候可以指定
             * envelope 消息包的内容，可从中获取消息id，消息routingkey，交换机，消息和重传标志(收到消息失败后是否需要重新发送)
             * properties 属性信息
             * body 消息
             */
            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"));
            }
        };
        //监听消息
        /**
         * 参数1：队列名称
         * 参数2：是否自动确认，设置为true为表示消息接收到自动向mq回复接收到了，mq接收到回复会删除消息，设置为false则需要手动确认
         * 参数3：消息接收到后回调
         */
        channel.basicConsume(TOPIC_QUEUE_1, true, consumer);

通配模式和路由模式区别：

通配模式可以实现路由模式的功能，并且比路由模式更加灵活。并且通配模式也可以实现pub/sub发布与订阅模式。

4.种工作模式总结

简单模式HelloWorld：一个生产者、一个消费者，不需要设置交换机（使用默认的交换机）
工作队列模式 Work Queue :一个生产者、多个消费者（竞争关系），不需要设置交换机（使用默认的交换机）
发布订阅模式 Publish/subscribe :需要设置类型为fanout的交换机，并且交换机和队列进行绑定，当发送消息到交换机后，交换机会将消息发送到绑定的队列
路由模式 Routing :需要设置类型为direct的交换机，交换机和队列进行绑定，并且指定routing key，当发送消息到交换机后，交换机会根据routing key将消息发送到对应的队列
通配符模式 Topic :需要设置类型为topic的交换机，交换机和队列进行绑定，并且指定通配符方式的routing key，当发送消息到交换机后，交换机会根据routing key将消息发送到对应的队列

5.Spring Boot整合RabbitMQ

搭建生产者工程

创建springboot工程导入依赖：

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

配置application.yml ：

增加配置类：

@Configuration
public class RabbitMQConfig {
    //交换机名称
    public static final String TOPIC_EXCHAGE = "springboot_topic_exchange";
    //队列名称
    public static final String TOPIC_QUEUE_1 = "springboot_topic_queue_1";

    private static final String TOPIC_QUEUE_2 = "springboot_topic_queue_2";

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

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

    @Bean("topic_queue_2")
    public Queue getQueue2(){
        return QueueBuilder.durable(TOPIC_QUEUE_2).build();
    }

    //绑定队列和交换机
    @Bean("binding1")
    public Binding getBinding1(@Qualifier("topic_queue_1") Queue queue,
                                     @Qualifier("topic_exchange") Exchange exchange){
        return BindingBuilder.bind(queue).to(exchange).with("opt.#").noargs();
    }

    //绑定队列和交换机
    @Bean("binding2")
    public Binding getBinding2(@Qualifier("topic_queue_2") Queue queue,
                                     @Qualifier("topic_exchange") Exchange exchange){
        return BindingBuilder.bind(queue).to(exchange).with("opt.update.*").noargs();
    }

    //绑定队列和交换机
    @Bean("binding3")
    public Binding getBinding3(@Qualifier("topic_queue_2") Queue queue,
                                     @Qualifier("topic_exchange") Exchange exchange){
        return BindingBuilder.bind(queue).to(exchange).with("opt.*").noargs();
    }

}

测试类：

@SpringBootTest(classes = Application.class)
@RunWith(SpringRunner.class)
public class ApplicationTest {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void testSend() {
        rabbitTemplate.convertAndSend(RabbitMQConfig.TOPIC_EXCHAGE, "opt.update", "执行opt.update操作");
    }
}

对于springboot项目生产者发送消息使用RabbitTemplate 类

搭建消费者工程

创建springboot项目，消费者导入依赖和application.yml配置一样，不需要@Configuration注解的配置类，但消费者需要使用@RabbitListener编写监听器：

@Component
public class RabbitMQListener {

    /**
     * 监听某个队列的消息
     * @param message 接收到的消息
     */
    @RabbitListener(queues = "springboot_topic_queue_1")
    public void myListener1(String message){
        System.out.println("springboot_topic_queue_1：" + message);
    }

    /**
     * 监听某个队列的消息
     * @param message 接收到的消息
     */
    @RabbitListener(queues = "springboot_topic_queue_2")
    public void myListener2(String message){
        System.out.println("springboot_topic_queue_2：" + message);
    }
}

启动消费着后，生产者发送消息结果如下：