RabbitMQ java操作

RabbitMQ提供了6种消息模型，但是第6种其实是RPC，并不是MQ，因此不予学习。那么也就剩下5种。
但是其实3、4、5这三种都属于订阅模型，只不过进行路由的方式不同

Helloworld-基本消息模型

一对一

创建Maven项目 test-rabbitmq
导入依赖

连接工具类

package cn.itsource.util;

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

/**
 * 获取链接的工具类
 */
public class ConnectionUtil {
    /**
     * 建立与RabbitMQ的连接
     * @return
     * @throws Exception
     */
    public static Connection getConnection() throws Exception {
        //定义连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        //设置服务地址
        factory.setHost("127.0.0.1");
        //端口
        factory.setPort(5672); //15672management管理界面的端口，5672是rabbitmq的端口
        //设置账号信息，用户名、密码、vhost
        factory.setVirtualHost("/");
        factory.setUsername("guest");
        factory.setPassword("guest");
        // 通过工程获取连接
        Connection connection = factory.newConnection();
        return connection;
    }
}

测试一下连接上没有

System.out.println(ConnectionUtil.getConnection());

由此可见我们java端访问的端口是5672

然后我们创建一个生产者和一个消费者

生产者

package org.leryoo._01base;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import org.leryoo.util.ConnectionUtil;


/**
 * 生产者
 */
public class Producer {
    //队列名称
    private static final String QUEUE = "helloworld";

    public static void main(String[] args) throws Exception {
        Connection connection = null;
        Channel channel = null;
        try {
            //获取连接
            connection = ConnectionUtil.getConnection();
            //创建与Exchange的通道，每个连接可以创建多个通道，每个通道代表一个会话任务
            channel = connection.createChannel();
            /**
             * 声明队列，如果Rabbit中没有此队列将自动创建
             * param1:队列名称
             * param2:是否持久化
             * param3:队列是否独占此连接
             * param4:队列不再使用时是否自动删除此队列
             * param5:队列参数
             */
            channel.queueDeclare(QUEUE, true, false, false, null);
            String message = "helloworld小明" + System.currentTimeMillis();
            /**
             * 消息发布方法
             * param1：Exchange的名称，如果没有指定，则使用Default Exchange
             * param2:routingKey（路由的key）,消息的路由Key，是用于Exchange（交换机）将消息转发到指定的消息队列
             * param3:消息包含的属性
             * param4：消息体
             */
            /**
             * 这里没有指定交换机，消息将发送给默认交换机，每个队列也会绑定那个默认的交换机，但是不能显
             示绑定或解除绑定
             * 默认的交换机，routingKey等于队列名称
             */
            channel.basicPublish("", QUEUE, null, message.getBytes());
            System.out.println("Send Message is:'" + message + "'");
        } catch (Exception ex) {
            ex.printStackTrace();
        } finally {
            if (channel != null) {
                channel.close();
            }
            if (connection != null) {
                connection.close();
            }
        }
    }
}

消费者

package org.leryoo._01base;

import com.rabbitmq.client.*;
import org.leryoo.util.ConnectionUtil;

import java.io.IOException;

public class Consumer {
    private static final String QUEUE = "helloworld";

    public static void main(String[] args) throws Exception {
        Connection connection = null;
        Channel channel = null;  //上上层，所以访问不了
        try
        {
            connection = ConnectionUtil.getConnection();
            channel = connection.createChannel();
            //声明队列
            channel.queueDeclare(QUEUE, true, false, false, null);
            //定义消费方法
            Channel finalChannel = channel; //匿名内部类只能访问上一层
            DefaultConsumer consumer = new DefaultConsumer(finalChannel) {
                /**
                 * 消费者接收消息调用此方法
                 * @param consumerTag 消费者的标签，在channel.basicConsume()去指定
                 * @param envelope 消息包的内容，可从中获取消息id，消息routingkey，交换机，消息和重传标志
                (收到消息失败后是否需要重新发送)
                 * @param properties
                 * @param body
                 */
                @Override
                public void handleDelivery(String consumerTag,
                                           Envelope envelope,
                                           AMQP.BasicProperties properties,
                                           byte[] body)
                        throws IOException {
                    //交换机
                    String exchange = envelope.getExchange();
                    //路由key
                    String routingKey = envelope.getRoutingKey();
                    //消息id
                    long deliveryTag = envelope.getDeliveryTag();
                    //消息内容
                    String msg = new String(body, "utf8");
                    System.out.println("receive message.." + msg);

                    //如果正常处理后需要做回复
                    finalChannel.basicAck(deliveryTag,false);
                }
            };
            /**
             * 监听队列:QUEUE 如果有消息来了，通过consumer来处理
             * 参数明细
             * 1、队列名称
             * 2、是否自动回复，设置为true为表示消息接收到自动向mq回复接收到了，mq接收到回复会删除消息，设置
             为false则需要手动回复
             * 3、消费消息的方法，消费者接收到消息后调用此方法
             */
            channel.basicConsume(QUEUE, true, consumer);

            //阻塞住，让他一直监听
           System.in.read();
        }catch (Exception e){

           e.printStackTrace();
        }finally {
            if (channel != null) {
                channel.close();
            }
            if (connection != null) {
                connection.close();
            }
        }

    }
}

然后我们运行消费者

然后访问http://localhost:15672 就能看到消息对队列里已经有消息在准备了

然后我们启动消费者

就能看到消息已经被消费者消费了

需要值得注意的是
我们需要在方法西面阻塞住进程如果不进行一个阻塞那么程序就会直接运行完毕要让消费者一直监听

这也控制台也才能打印

说明：
1 启动的顺序都可以不论先后
2

关于自动回复如果设置成true 就是自动回复当一有消息进来消费者就会进行一个自动回复这样会出现一个问题就是如果消费者在程序执行的过程中运行出错了那么就会删除掉这消息导致消息的一个丢失

这就涉及到了消息确认机制（ACK）

消息确认机制（ACK）

通过刚才的案例可以看出，消息一旦被消费者接收，队列中的消息就会被删除。

那么问题来了：RabbitMQ怎么知道消息被接收了呢？

如果消费者领取消息后，还没执行操作就挂掉了呢？或者抛出了异常？消息消费失败，但是RabbitMQ无从得知，这样消息就丢失了！

因此，RabbitMQ有一个ACK机制。当消费者获取消息后，会向RabbitMQ发送回执ACK，告知消息已经被接收。不过这种回执ACK分两种情况：

自动ACK：消息一旦被接收，消费者自动发送ACK 收到还没有正确处理。。
手动ACK：消息接收后，不会发送ACK，需要手动调用，等到正确处理后再来手动确认

那么怎么选择呢

如果消息不太重要，丢失也没有影响，那么自动ACK会比较方便
如果消息非常重要，不容丢失。那么最好在消费完成后手动ACK，否则接收消息后就自动ACK，RabbitMQ就会把消息从队列中删除。如果此时消费者宕机，那么消息就丢失了

我们来测试一下我们来制造一个异常

然后启动

可以发现消费者的控制台报错了

但是我们的消息并没有消失

这样消息就会还原回去

然后我们在异常处理完成之后我们需要手动确认实现

需要值得注意的是:
因为这个方法是在匿名内部类里面然后内部类又在try/catch里面所以不能直接访问channel 这个变量我们需要将channel在try/catch里面再进行定义

如果要确保rabbitmq中怎么确保一个消息被正常处理 ————> 手动回复机制
总体的流程就是

发送端操作流程
1）创建连接
2）创建通道
3）声明队列
4）发送消息
接收端
1）创建连接
2）创建通道
3）声明队列
4）监听队列
5）接收消息
6）ack回复-自动回复手动回复

Work queues

work queues与入门程序相比，多了一个消费端，两个消费端共同消费同一个队列中的消息。
应用场景：对于任务过重或任务较多情况使用工作队列可以提高任务处理的速度

工作队列，又称任务队列。主要思想就是避免执行资源密集型任务时，必须等待它执行完成。相反我们稍后完成任务，我们将任务封装为消息并将其发送到队列。在后台运行的工作进程将获取任务并最终执行作业。当你运行许多工人时，任务将在他们之间共享，但是一个消息只能被一个消费者获取。

这个概念在Web应用程序中特别有用，因为在短的HTTP请求窗口中无法处理复杂的任务

接下来我们来模拟这个流程：

P：生产者：任务的发布者

C1：消费者，领取任务并且完成任务，假设完成速度较快

C2：消费者2：领取任务并完成任务，假设完成速度慢

我们在C2后面

然后让两个消费者同时启动让生产者发送50条消息

可以发现

两个消费者接受消息的条数是一样的这样就会出现问题

消费者1比消费者2的效率要高，一次任务的耗时较短
然而两人最终消费的消息数量是一样的
消费者1大量时间处于空闲状态，消费者2一直忙碌

现在的状态属于是把任务平均分配，正确的做法应该是消费越快的人，消费的越多

能者多劳

我们可以使用basicQos方法和prefetchCount = 1设置。这告诉RabbitMQ一次不要向工作人员发送多于一条消息。或者换句话说，不要向工作人员发送新消息，直到它处理并确认了前一个消息。相反，它会将其分派给不是仍然忙碌的下一个工作人员。再同一时间一个消费者还没有处理的任务只能有一个

再次测试
能力弱的：

能力强的

需要注意的是：因为需要处理完了才去抓取下一个所以需要设置手动回复

订阅模型分类

在之前的模式中，我们创建了一个工作队列。工作队列背后的假设是：每个任务只被传递给一个工作人员。在这一部分，我们将做一些完全不同的事情 - 我们将会传递一个信息给多个消费者。这种模式被称为“发布/订阅”。

一对多：1条消息对应多个消费者。可以给一个队列绑多个消费者一个交换机绑多个队列

解读：

1、1个生产者，多个消费者

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

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

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

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

X（Exchanges）：交换机一方面：接收生产者发送的消息。另一方面：知道如何处理消息，例如递交给某个特别队列、递交给所有队列、或是将消息丢弃。到底如何操作，取决于Exchange的类型。

分类

Exchange类型有以下几种：

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

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

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

我们这里先看一下 Fanout：即广播模式

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

订阅模型-FANOUT

发布订阅模式：
在广播模式下，消息发送流程是这样的：

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

生产者：
两个变化：

声明Exchange，不再声明Queue
发送消息到Exchange，不再发送到Queue

public class Producer {
    //队列名称
    private static final String QUEUE = "helloworld";
    private final static String EXCHANGE_NAME = "fanout_exchange_test";
    public static void main(String[] args) throws Exception {
        Connection connection = null;
        Channel channel = null;
        try {
            //获取连接
            connection = ConnectionUtil.getConnection();
            //创建与Exchange的通道，每个连接可以创建多个通道，每个通道代表一个会话任务
            channel = connection.createChannel();
            String message = "helloworld小明" + System.currentTimeMillis();

            //声明交换-fanout广播模式
            channel.exchangeDeclare(EXCHANGE_NAME,"fanout");
            channel.basicPublish(EXCHANGE_NAME, "", null, message.getBytes());
            System.out.println("Send Message is:'" + message + "'");

        } catch (Exception ex) {
            ex.printStackTrace();
        } finally {
            if (channel != null) {
                channel.close();
            }
            if (connection != null) {
                connection.close();
            }
        }
    }
}

消费者1

public class Consumer1 {
    private final static String QUEUE_NAME = "fanout_exchange_queue_1";
    private final static String EXCHANGE_NAME = "fanout_exchange_test";

    public static void main(String[] args) throws Exception {
        Connection connection = null;
        Channel channel = null;  //上上层，所以访问不了
        try
        {
            connection = ConnectionUtil.getConnection();
            channel = connection.createChannel();
            //声明队列
            channel.queueDeclare(QUEUE_NAME, true, false, false, null);

            //队列绑定交换机
            channel.queueBind(QUEUE_NAME,EXCHANGE_NAME,"");
            //定义消费方法
            Channel finalChannel = channel; //匿名内部类只能访问上一层
            DefaultConsumer consumer = new DefaultConsumer(finalChannel) {
                @Override
                public void handleDelivery(String consumerTag,
                                           Envelope envelope,
                                           AMQP.BasicProperties properties,
                                           byte[] body)
                        throws IOException {
                    //交换机
                    String exchange = envelope.getExchange();
                    //路由key
                    String routingKey = envelope.getRoutingKey();
                    //消息id
                    long deliveryTag = envelope.getDeliveryTag();
                    //消息内容
                    String msg = new String(body, "utf8");
                    System.out.println("Consumer1 receive message.." + msg);

                }
            };
            channel.basicConsume(QUEUE_NAME, true, consumer);

            System.in.read();
        }catch (Exception e){

            e.printStackTrace();
        }finally {
            if (channel != null) {
                channel.close();
            }
            if (connection != null) {
                connection.close();
            }
        }

    }
}

消费者2

public class Consumer2 {
    private final static String QUEUE_NAME = "fanout_exchange_queue_2";
    private final static String EXCHANGE_NAME = "fanout_exchange_test";

    public static void main(String[] args) throws Exception {
        Connection connection = null;
        Channel channel = null;  //上上层，所以访问不了
        try
        {
            connection = ConnectionUtil.getConnection();
            channel = connection.createChannel();
            //声明队列
            channel.queueDeclare(QUEUE_NAME, true, false, false, null);

            //队列绑定交换机
            channel.queueBind(QUEUE_NAME,EXCHANGE_NAME,"");
            //定义消费方法
            Channel finalChannel = channel; //匿名内部类只能访问上一层
            DefaultConsumer consumer = new DefaultConsumer(finalChannel) {
                @Override
                public void handleDelivery(String consumerTag,
                                           Envelope envelope,
                                           AMQP.BasicProperties properties,
                                           byte[] body)
                        throws IOException {
                    //交换机
                    String exchange = envelope.getExchange();
                    //路由key
                    String routingKey = envelope.getRoutingKey();
                    //消息id
                    long deliveryTag = envelope.getDeliveryTag();
                    //消息内容
                    String msg = new String(body, "utf8");
                    System.out.println("Consumer2 receive message.." + msg);

                }
            };
            channel.basicConsume(QUEUE_NAME, true, consumer);

            //阻塞住，让他一直监听
           System.in.read();
        }catch (Exception e){

           e.printStackTrace();
        }finally {
            if (channel != null) {
                channel.close();
            }
            if (connection != null) {
                connection.close();
            }
        }

    }
}

启动他们然后在网页中查看

说明：我们先声明一个交换机然后将多个队列绑定到交换机上然后消费者在去监听队列当发送了一条消息到交换机后我们将消息发送到绑定到这个交换机上的队列然后再去由消费者调用

注意：启动的时候我们需要先启动交换机不然我们连交换机都没有

订阅模型-Direct

有选择性的接收消息

在订阅模式中，生产者发布消息，所有消费者都可以获取所有消息。

在路由模式中，我们将添加一个功能 - 我们将只能订阅一部分消息。例如，我们只能将重要的错误消息引导到日志文件（以节省磁盘空间），同时仍然能够在控制台上打印所有日志消息。

但是，在某些场景下，我们希望不同的消息被不同的队列消费。这时就要用到Direct类型的Exchange。

在Direct模型下，队列与交换机的绑定，不能是任意绑定了，而是要指定一个RoutingKey（路由key）

消息的发送方在向Exchange发送消息时，也必须指定消息的routing key。

P：生产者，向Exchange发送消息，发送消息时，会指定一个routing key。才知道要转给哪些队列

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

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

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

通过消息发送时指定的routingkey判断转发给那些队列。

生产者

消费者1

消费者2

消费者3

消费者4

说明这里的消费者1和消费者2是不同的队列而消费者3和消费者4 是相同的队列不同的消费者

传递对象可以通过json字符串的方式

订阅模型-Topics

Topic类型的Exchange与Direct相比，都是可以根据RoutingKey把消息路由到不同的队列。只不过Topic类型Exchange可以让队列在绑定Routing key 的时候使用通配符！

Routingkey 一般都是有一个或多个单词组成，多个单词之间以”.”分割，例如： goods.insert

通配符规则：
#：匹配一个或多个词
*：匹配不多不少恰好1个词

举例：
audit.#：能够匹配audit.irs.corporate 或者 audit.irs
audit.*：只能匹配audit.irs

生产者：

消费者1

消费者2

如果生产者的routing key换成

消费者1将不再接受到

消费者2依然能接受

Header模式和RPC我们基本不用所以我在这也不介绍了大家想要了解请自行学习

持久化-解决数据安全

如何避免消息丢失？

1）消费者的ACK机制。可以防止消费者丢失消息。

2）但是，如果在消费者消费之前，MQ就宕机了，消息就没了

是可以将消息进行持久化呢？

要将消息持久化，前提是：队列、Exchange都持久化

交换机持久化

队列持久化

消息持久化

Springboot整合rabbitmq

先创建一个Maven项目用于我们测试springbootrabbitmq

首先我们需要导入依赖

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

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


<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>2.0.5.RELEASE</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

创建RabbitMQ的配置类

package org.leryoo.config;

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

@Configuration
public class RabbitMqConfig {
    //两个队列
    public static final String QUEUE_INFORM_EMAIL = "queue_inform_email";
    public static final String QUEUE_INFORM_SMS = "queue_inform_sms";
    //交换机名字
    public static final String EXCHANGE_TOPICS_INFORM = "exchange_topics_inform";


    /**
     * 交换机配置
     * ExchangeBuilder提供了fanout、direct、topic、header交换机类型的配置
     *
     * @return the exchange
     */
    @Bean(EXCHANGE_TOPICS_INFORM) //spring中bean
    public Exchange EXCHANGE_TOPICS_INFORM() {
        //durable(true)持久化，消息队列重启后交换机仍然存在
        return ExchangeBuilder.topicExchange(EXCHANGE_TOPICS_INFORM).durable(true).build();
    }


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

    //声明队列
    @Bean(QUEUE_INFORM_EMAIL)
    public Queue QUEUE_INFORM_EMAIL() {
        Queue queue = new Queue(QUEUE_INFORM_EMAIL);
        return queue;
    }


    /**
     * channel.queueBind(INFORM_QUEUE_SMS,"inform_exchange_topic","inform.#.sms.#");
     * 绑定队列到交换机 .
     *
     * @param queue    the queue
     * @param exchange the exchange
     * @return the binding
     */
    @Bean
    public Binding BINDING_QUEUE_INFORM_SMS(@Qualifier(QUEUE_INFORM_SMS) Queue queue, //通过名字从spring获取bean
                                            @Qualifier(EXCHANGE_TOPICS_INFORM) Exchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with("inform.#.sms.#").noargs();
    }

    @Bean
    public Binding BINDING_QUEUE_INFORM_EMAIL(@Qualifier(QUEUE_INFORM_EMAIL) Queue queue,
                                              @Qualifier(EXCHANGE_TOPICS_INFORM) Exchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with("inform.#.email.#").noargs();
    }
}

测试代码
生产者

@RunWith(SpringRunner.class)
@SpringBootTest(classes = App.class)
public class ProducerTest {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void sendMsg() {

        String message = "sms message!";
        rabbitTemplate.convertAndSend(RabbitMqConfig.EXCHANGE_TOPICS_INFORM,"inform.email",
                message);

    }
}

消费者：

@Component
public class MessageHandler {

    //绑定sms队列的方法

    @RabbitListener(queues = {RabbitMqConfig.QUEUE_INFORM_SMS})
    public void xxx(String msg, Message message, Channel channel){

        System.out.println("sms message："+msg);
    }

    //绑定email队列方法
    @RabbitListener(queues = {RabbitMqConfig.QUEUE_INFORM_EMAIL})
    public void yyy(String msg, Message message, Channel channel)
    {
        System.out.println("email message："+msg);
    }
}

集成完毕

Springcloud微服务项目——人力资源管理(HRM)Day07_2 消息队列RabbitMQ操作

RabbitMQ java操作

Helloworld-基本消息模型

消息确认机制（ACK）

Work queues

能者多劳

订阅模型分类

分类

订阅模型-FANOUT

订阅模型-Direct

订阅模型-Topics

持久化-解决数据安全

交换机持久化

队列持久化

消息持久化

Springboot整合rabbitmq

Spring data JPARepository的一些方法&&jpa-spec插件

Redis客戶端的基本使用和在java中使用

包裝類 -- 自動拆箱和自動裝箱 -- 享元模式

面試題(0)之——Java String

Shiro集成到Spring

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結