RabbitMQ入门到集成SpringBoot

最新推荐文章于 2024-07-13 22:53:26 发布
最新推荐文章于 2024-07-13 22:53:26 发布
阅读量211 收藏
点赞数
分类专栏： 后端 文章标签： rabbitmq java spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kingsleyhe/article/details/120338914
版权

文章目录

何夜息随笔录-RabbitMQ

MQ：（MessageQueue）消息队列，什么是消息队列，其实就是消息广播的发送模型，就像从微信公众号发送文章一样，发布者发布一篇文章，那么接受者就能就收到这个消息，或者老师发布了通知，那么学生通过手机能够接收，其实就是在生产者和消费者之间加入了一个消息队列，那么原来生产者要发送信息是直接发送到消费者，就会造成可能有的消费者不需要也接收到了，那么通过中间加一层，没有什么是加一层解决不了的。

通过中间加一层消息队列，那么生产者和消费者就解耦了，消息具体怎么发送，发送给谁，就交给消息队列来处理，这就是消息队列的作用。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-brgvjOBK-1631801852258)(https://www.heyexi.com/markdown/image-20210815224148599.png)]

RabbitMQ是用erlang语言开发的，基于AMQP，这是高级消息队列协议，和一些通信协议一样，比如POP3，Http，AMQP也是通信协议，有统一的规范，消息队列就是通过这个协议进行通信的。

市场上还有很多消息队列的产品：Kafka、MetaMQ、Redis、ZeroMQ等等，Redis也是哦，它里面有一个订阅发布的消息队列模型，所以也可以算作消息队列。当然这些产品都是用不同的特点的，要根据具体的业务来进行选择，选择RabbitMQ的原因是SpringBoot默认是已经集成了这个消息队列，而且使用方便，社区活跃，对高并发处理比较好。

工作原理

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-J8yd5eSi-1631801852278)(https://www.heyexi.com/markdown/image-20210815225405317.png)]

首先是可以有多个生成者Producer，它想要发送消息，那么需要先和消息队列通过通道建立连接，然后消息队列服务进程Broker，里面有一个交换机Exchange，交换机把消息按照一定的规则，发送到队列Queue进行暂存，然后消费者Consumer想要获取消息，首先需要监听队列，然后需要获得消息的话就和和Broker建立连接，这些连接和消费者一样通过Channel通道建立，然后从队列中获得消息，这就是一个消息发送到接收的流程。

生产者和消费者都是通过TCP协议通过通道来和消息队列服务进程建立连接的。

下载安装

Windows下安装需要安装Erlang语言，然后去RabbitMQ下载对应的版本，我这里直接在服务器上通过docker部署安装。

docker pull rabbitmq:management

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BjKx8T6t-1631801852280)(https://www.heyexi.com/markdown/image-20210815232921217.png)]

docker run --name rabbitmq -d -p 15672:15672 -p 5672:5672 a0a2d74e6e6a
-p指定容器内部端口号与宿主机之间的映射，rabbitMq默认要使用15672为其web端界面访问时端口，5672为数据通信端口

然后还要去记得打开服务器安全组的端口

image-20210815233730196

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4IW9Ewnd-1631801852284)(https://www.heyexi.com/markdown/image-20210815233816035.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KJBAzLGc-1631801852286)(https://www.heyexi.com/markdown/image-20210815233938896.png)]

然后通过ip:15672端口进行访问，因为我们在运行的使用了management所以是带有面板的，然后进行登录，默认的账号和密码都是guest

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8jSg3Rqi-1631801852287)(https://www.heyexi.com/markdown/image-20210815234048527.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mepr3Qwx-1631801852288)(https://www.heyexi.com/markdown/image-20210815234140950.png)]

在这里我们就可以看到上面说到的连接、通道、交换机、队列等等比较重要的概念。

我们可以添加一个账号

docker exec -it rabbitmq bin/bash  #进入容器
rabbitmqctl add_user root 密码  #添加一个用户
rabbitmqctl set_permissions -p / root ".*" ".*" ".*" #赋予所以权限
rabbitmqctl set_user_tags root administrator # 赋予角色

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GL0U3OF8-1631801852289)(https://www.heyexi.com/markdown/image-20210815234916720.png)]

rabbitmqctl delete_user Username #删除用户
第一个Helloworld

首先需要添加依赖

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

然后我们建一个生成者的包，实现让生成者生产消息。

根据流程：

  1. 创建一个连接工厂，通过连接工程能创建连接对象，和mybatis是类似的，都是一层建一层，使用了工程模式的设计模式。
  2. 创建连接对象，就是要指定要连接到哪个MQ服务器，设置连接账号密码地址和虚拟机之类的，虚拟机就是一个相当于是一个路由，这个连接的消息都放在这个虚拟机中。
  3. 通过连接对象创建通道
  4. 通过通道声明队列
  5. 通过通道发送消息
/**
 * 创建一个生产者测试类
 */
public class ProducerTest
{
    public static void main(String[] args)
    {
        //创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //设置连接对象的属性
        connectionFactory.setHost("地址");
        connectionFactory.setUsername("root");//用户名
        connectionFactory.setPassword("密码");//密码
        connectionFactory.setPort(5672);//端口
        connectionFactory.setVirtualHost("/");//虚拟机

        //通过工厂创建连接对象
        Connection connection = null;
        try
        {
            connection = connectionFactory.newConnection();

            //创建通道
            Channel channel = connection.createChannel();
            //声明对象
            /**
             * 参数：
             *  1 队列名称
             *  2 是否持久化：就是重启MQ后是否存在
             *  3 是否独占连接，就是连接对象销毁后此队列是否还存在
             *  4 是否自动删除,就是空闲不用会自己删除
             *  5 通过map设置一些扩展参数
             */
            channel.queueDeclare("heyexi",true,false,false,null);

            //从生成者发送消息
            String msg = "你好,这是来自生产者何夜息的消息哦!";

            /**
             * 参数：
             *  1 交换机，不知道就使用默认的交换机
             *  2 路由key,就是要通过交换机发送到哪个指定的队列，如果使用默认的就要指定队列名称
             *  3 消息的属性
             *  4 消息的内容
             */
            channel.basicPublish("","heyexi",null,msg.getBytes());

            System.out.println("发送成功");
        } catch (IOException | TimeoutException e)
        {
            e.printStackTrace();
        } finally
        {

        }
    }
}

然后我们打开后台查看

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-h5O6n0j9-1631801852295)(https://www.heyexi.com/markdown/image-20210816215148693.png)]

image-20210816215229169

然后我们就创建一个消费者，获取上面创建的消息

消费者和上面一样需要获取连接对象，创建队列，不同的只在于生产者是发布消息，而消费者是接受消息，然后定义如何消费消息，就是消费方法。


/**
 * 消费者
 */
public class ConsumerTest
{
    public static void main(String[] args)
    {
        //创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //设置连接对象的属性
        connectionFactory.setHost("地址");
        connectionFactory.setUsername("root");//用户名
        connectionFactory.setPassword("密码");//密码
        connectionFactory.setPort(5672);//端口
        connectionFactory.setVirtualHost("/");//虚拟机

        //通过工厂创建连接对象
        Connection connection = null;
        try
        {
            connection = connectionFactory.newConnection();

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

            /**
             * 参数：
             *  1 队列名称
             *  2 是否持久化：就是重启MQ后是否存在
             *  3 是否独占连接，就是连接对象销毁后此队列是否还存在
             *  4 是否自动删除,就是空闲不用会自己删除
             *  5 通过map设置一些扩展参数
             */
            channel.queueDeclare("heyexi",true,false,false,null);

            //消费方法
            DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
                //重写接收消息后要执行的方法

                /**
                 * @param consumerTag 标识消费者
                 * @param envelope 信封：可以拿到交换机 可以获得消息id
                 * @param properties 属性值
                 * @param body 消息内容
                 * @throws IOException
                 */
                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException
                {
                    String msg = new String(body,"utf-8");
                    System.out.println("收到消息:"+msg);
                }
            };

            // 监听队列
            /**
             * 参数
             *  1 队列名称
             *  2 是否自动回复
             *  3 消费方法：接收到消息后需要执行的方法
             */
            channel.basicConsume("heyexi",true,defaultConsumer);

            System.out.println("发送成功");
        } catch (IOException | TimeoutException e)
        {
            e.printStackTrace();
        } finally
        {

        }
    }
}

然后我们启动消费者程序，那么只要生产者发送消息那么消费者都能收到

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FIvDW3FM-1631801852298)(https://www.heyexi.com/markdown/image-20210816223423300.png)]

我们重新启动生成者

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-o8Nyt2Ug-1631801852300)(https://www.heyexi.com/markdown/image-20210816223453835.png)]

而且如果我们不关闭连接，这两个程序都是用while(true)来一直监听的，这就是利用了观察者模式。

还可以从网页后台发送哦

image-20210816235214331

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7hcZddLC-1631801852302)(https://www.heyexi.com/markdown/image-20210816235222022.png)]

还是很有趣的

工作模式

  1. 简单模式：一个生产者，一个消费者

    ​ 简单模式就是上面的例子，一个生产者给一个消费者发送消息。

  2. work模式：一个生产者，多个消费者，每个消费者获取到的消息唯一（消费者彼此竞争成为接收者）

    ​ 工作模式是一个生产者发送消息，然后多个消费者共同监听同一个队列，但是它有一个特点，就是一个消息不能重复消费，就是生产者发送一个消息，那么只会到其中一个消费者，然后再发送消息时采用轮询的方式再发给另一个。

    ​ image-20210821184029223

    这里运行两个消费者，然后启动生产者。

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AolUv3uj-1631801852304)(https://www.heyexi.com/markdown/image-20210821184103535.png)]

    只有其中的一个收到了消息，另一个没有。再次运行生产者另一个消费者才能收到消息。

  3. 订阅模式：一个生产者发送的消息会被多个消费者获取。

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nIgfq8dB-1631801852305)(https://www.heyexi.com/markdown/image-20210821192203789.png)]

    ​ 发布订阅模式消费者只监听它订阅了的队列，中间有个X代表交换机，生产者通过交换机给不同的队列发消息。

    ​ 现在我们定义一个发布者，然后创建一个交换机，两个队列，再将交换机和队列通过通道进行绑定，最后再弄两个消费者分别监听队列1和队列2.

    **
 * 创建一个生产者
 */
public class Producer2
{
    public static void main(String[] args)
    {
        //创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //设置连接对象的属性
        connectionFactory.setHost("ip");
        connectionFactory.setUsername("root");//用户名
        connectionFactory.setPassword("pwd");//密码
        connectionFactory.setPort(5672);//端口
        connectionFactory.setVirtualHost("/");//虚拟机

        //通过工厂创建连接对象
        Connection connection = null;
        try
        {
            connection = connectionFactory.newConnection();

            //创建通道
            Channel channel = connection.createChannel();
            //声明对象
            /**
             * 参数：
             *  1 队列名称
             *  2 是否持久化：就是重启MQ后是否存在
             *  3 是否独占连接，就是连接对象销毁后此队列是否还存在
             *  4 是否自动删除,就是空闲不用会自己删除
             *  5 通过map设置一些扩展参数
             */
            //生成两个队列
            channel.queueDeclare("q1",true,false,false,null);
            channel.queueDeclare("q2",true,false,false,null);

            //声明交换机
            /**
             * 参数：
             * 1. 交换机名称
             * 2. 类型：通过定义的字符串常量声明
             *      HEADERS: 对应headers工作模式
             *      DIRECT: 对应路由工作模式
             *      FANOUT: 对应t发布订阅模式
             *      TOPIC: 对应topic工作模式
             */
            channel.exchangeDeclare("ex", BuiltinExchangeType.FANOUT);

            //绑定交换机和队列
            /**
             * 参数：
             * 1. 队列名称
             * 2. 交换机名称
             * 3. 路由key,发布订阅模式中为空
             */
            channel.queueBind("q1","ex","");
            channel.queueBind("q2","ex","");

            //发送消息:这时候要指定给交换机发送,而不是给队列发送
            for (int i = 0; i < 6; i++)
            {
                String msg = "来自发布订阅模式的消息";
                channel.basicPublish("ex","",null,msg.getBytes());
            }

            System.out.println("发送成功");
        } catch (IOException | TimeoutException e)
        {
            e.printStackTrace();
        } finally
        {

        }
    }
}

    然后我们创建两个生成者，这两个生成者需要创建和发布者一样的交换机，然后队列只需要生成自己要监听的队列，然后绑定就行。

    /**
 * 消费者1
 */
public class Consumer1
{
    public static void main(String[] args)
    {
        //创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //设置连接对象的属性
        connectionFactory.setHost("ip");
        connectionFactory.setUsername("root");//用户名
        connectionFactory.setPassword("pwd");//密码
        connectionFactory.setPort(5672);//端口
        connectionFactory.setVirtualHost("/");//虚拟机

        //通过工厂创建连接对象
        Connection connection = null;
        try
        {
            connection = connectionFactory.newConnection();

            //创建通道
            Channel channel = connection.createChannel();
            //创建交换机
            channel.exchangeDeclare("ex",BuiltinExchangeType.FANOUT);
            /**
             * 参数：
             *  1 队列名称
             *  2 是否持久化：就是重启MQ后是否存在
             *  3 是否独占连接，就是连接对象销毁后此队列是否还存在
             *  4 是否自动删除,就是空闲不用会自己删除
             *  5 通过map设置一些扩展参数
             */
            channel.queueDeclare("q1",true,false,false,null);

            //绑定队列
            channel.queueBind("q1","ex","");

            //消费方法
            DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
                //重写接收消息后要执行的方法
                /**
                 * @param consumerTag 标识消费者
                 * @param envelope 信封：可以拿到交换机 可以获得消息id
                 * @param properties 属性值
                 * @param body 消息内容
                 * @throws IOException
                 */
                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException
                {
                    String msg = new String(body,"utf-8");
                    System.out.println("消费者1收到消息:"+msg);
                }
            };

            // 监听队列1
            /**
             * 参数
             *  1 队列名称
             *  2 是否自动回复
             *  3 消费方法：接收到消息后需要执行的方法
             */
            channel.basicConsume("q1",true,defaultConsumer);
        } catch (IOException | TimeoutException e)
        {
            e.printStackTrace();
        } finally
        {

        }
    }
}

    /**
 * 消费者1
 */
public class Consumer2
{
    public static void main(String[] args)
    {
        //创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //设置连接对象的属性
        connectionFactory.setHost("8.129.54.174");
        connectionFactory.setUsername("root");//用户名
        connectionFactory.setPassword("kingsley");//密码
        connectionFactory.setPort(5672);//端口
        connectionFactory.setVirtualHost("/");//虚拟机

        //通过工厂创建连接对象
        Connection connection = null;
        try
        {
            connection = connectionFactory.newConnection();

            //创建通道
            Channel channel = connection.createChannel();
            //创建交换机
            channel.exchangeDeclare("ex",BuiltinExchangeType.FANOUT);
            /**
             * 参数：
             *  1 队列名称
             *  2 是否持久化：就是重启MQ后是否存在
             *  3 是否独占连接，就是连接对象销毁后此队列是否还存在
             *  4 是否自动删除,就是空闲不用会自己删除
             *  5 通过map设置一些扩展参数
             */
            channel.queueDeclare("q2",true,false,false,null);

            //绑定队列
            channel.queueBind("q2","ex","");

            //消费方法
            DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
                //重写接收消息后要执行的方法
                /**
                 * @param consumerTag 标识消费者
                 * @param envelope 信封：可以拿到交换机 可以获得消息id
                 * @param properties 属性值
                 * @param body 消息内容
                 * @throws IOException
                 */
                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException
                {
                    String msg = new String(body,"utf-8");
                    System.out.println("消费者2收到消息:"+msg);
                }
            };

            // 监听队列1
            /**
             * 参数
             *  1 队列名称
             *  2 是否自动回复
             *  3 消费方法：接收到消息后需要执行的方法
             */
            channel.basicConsume("q2",true,defaultConsumer);
        } catch (IOException | TimeoutException e)
        {
            e.printStackTrace();
        } finally
        {

        }
    }
}

    然后启动发布者，顺序不重要，因为都声明了交换和队列。

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jrhi9d0p-1631801852306)(https://www.heyexi.com/markdown/image-20210826202550235.png)]

    ​ 可以看到有12条消息等待发送，也就是有两个队列，每个队列要发送六条，一共就是十二个，我先启动消费者1。

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-afoTmYj4-1631801852307)(https://www.heyexi.com/markdown/image-20210826202710058.png)]

    image-20210826202717126

    这样消息就只有消费者2的没发送了。

    最后我从后台发给消息给队列1，那么就只有监听了队列1的消费者才能接收到。

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FAIS446f-1631801852309)(https://www.heyexi.com/markdown/image-20210826202920310.png)]

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5tU0HUa9-1631801852310)(https://www.heyexi.com/markdown/image-20210826202928475.png)]

  4. 我路由模式：发送消息到交换机并且要指定路由key ，消费者将队列绑定到交换机时需要指定路由key

    ​ [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-z4DQD5VX-1631801852312)(https://www.heyexi.com/markdown/image-20210826204245149.png)]

    路由模式和发布订阅类似，只是多了一个routingKey，发布订阅模式是像工作模式一样发布者发的消息都会发送到每个队列，然后监听队列的多个用户进行轮询获取消息。而路由模式可以通过这个路由key，来指定发送给哪个队列，队列监听了哪个路由key，那么就会接收到那个消息，如上图第二个和第一个都能接受到error的消息，但是第一个除了这个都不能接受到。

    我们来实现通过路由模式给不同的队列发送消息。

    /**
 * 创建一个生产者
 */
public class ProducerRouter
{
    private static String exchange_name = "exchange001";//路由器名称
    private static String q1 = "q1";//队列
    private static String q2 = "q2";//队列
    private static String key_qq_email = "qq";//路由key给QQ发送
    private static String key_yeah_email = "yeah";//路由key给网易邮箱发送

    public static void main(String[] args)
    {
        //创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //设置连接对象的属性
        connectionFactory.setHost("ip");
        connectionFactory.setUsername("root");//用户名
        connectionFactory.setPassword("pwd");//密码
        connectionFactory.setPort(5672);//端口
        connectionFactory.setVirtualHost("/");//虚拟机

        //通过工厂创建连接对象
        Connection connection = null;
        try
        {
            connection = connectionFactory.newConnection();

            //创建通道
            Channel channel = connection.createChannel();
            //声明对象
            /**
             * 参数：
             *  1 队列名称
             *  2 是否持久化：就是重启MQ后是否存在
             *  3 是否独占连接，就是连接对象销毁后此队列是否还存在
             *  4 是否自动删除,就是空闲不用会自己删除
             *  5 通过map设置一些扩展参数
             */
            //生成两个队列
            channel.queueDeclare(q1,true,false,false,null);
            channel.queueDeclare(q2,true,false,false,null);


            //声明交换机
            /**
             * 参数：
             * 1. 交换机名称
             * 2. 类型：通过定义的字符串常量声明
             *      HEADERS: 对应headers工作模式
             *      DIRECT: 对应路由工作模式
             *      FANOUT: 对应t发布订阅模式
             *      TOPIC: 对应topic工作模式
             */
            channel.exchangeDeclare(exchange_name, BuiltinExchangeType.DIRECT);

            //绑定交换机和队列
            /**
             * 参数：
             * 1. 队列名称
             * 2. 交换机名称
             * 3. 路由key,路由模式中一套指定路由Key了
             * 这里队列1监听qq和网易邮箱的消息，而队列2只监听网易
             * 监听多个路由Key可以传入map
             */
            channel.queueBind(q1,exchange_name,key_qq_email);
            channel.queueBind(q1,exchange_name,key_yeah_email);
            channel.queueBind(q2,exchange_name,key_yeah_email);

            String msg = "";
            //发送消息:给QQ邮箱的发消息
            msg = "通过路由模式给QQ邮箱发消息";
            channel.basicPublish(exchange_name,key_qq_email,null,msg.getBytes());

            //发送消息:给挖网易邮箱的发消息
            msg = "通过路由模式给网易邮箱发消息";
            channel.basicPublish(exchange_name,key_yeah_email,null,msg.getBytes());


            System.out.println("发送成功");
        } catch (IOException | TimeoutException e)
        {
            e.printStackTrace();
        } finally
        {

        }
    }
}

    ​ 然后创建两个消费者，一个监听队列1，一个监听队列2.

    /**
 * 消费者1
 */
public class ConsumerRouter1
{
    private static String exchange_name = "exchange001";//路由器名称
    private static String q1 = "q1";//队列
    private static String key_qq_email = "qq";//路由key给QQ发送
    private static String key_yeah_email = "yeah";//路由key给网易邮箱发送

    public static void main(String[] args)
    {
        //创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //设置连接对象的属性
        connectionFactory.setHost("ip");
        connectionFactory.setUsername("root");//用户名
        connectionFactory.setPassword("pwd");//密码
        connectionFactory.setPort(5672);//端口
        connectionFactory.setVirtualHost("/");//虚拟机

        //通过工厂创建连接对象
        Connection connection = null;
        try
        {
            connection = connectionFactory.newConnection();
            //创建通道
            Channel channel = connection.createChannel();
            //创建交换机
            channel.exchangeDeclare(exchange_name,BuiltinExchangeType.DIRECT);
            /**
             * 参数：
             *  1 队列名称
             *  2 是否持久化：就是重启MQ后是否存在
             *  3 是否独占连接，就是连接对象销毁后此队列是否还存在
             *  4 是否自动删除,就是空闲不用会自己删除
             *  5 通过map设置一些扩展参数
             */
            channel.queueDeclare(q1,true,false,false,null);

            //绑定队列
            channel.queueBind(q1,exchange_name,key_qq_email);
            //channel.queueBind(q1,exchange_name,key_yeah_email);

            //消费方法
            DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
                //重写接收消息后要执行的方法
                /**
                 * @param consumerTag 标识消费者
                 * @param envelope 信封：可以拿到交换机 可以获得消息id
                 * @param properties 属性值
                 * @param body 消息内容
                 * @throws IOException
                 */
                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException
                {
                    String msg = new String(body,"utf-8");
                    System.out.println("消费者1收到消息:"+msg);
                }
            };

            // 监听队列1
            /**
             * 参数
             *  1 队列名称
             *  2 是否自动回复
             *  3 消费方法：接收到消息后需要执行的方法
             */
            channel.basicConsume(q1,true,defaultConsumer);
        } catch (IOException | TimeoutException e)
        {
            e.printStackTrace();
        } finally
        {

        }
    }
}


    /**
 * 消费者1
 */
public class ConsumerRouter2
{
    private static String exchange_name = "exchange001";//路由器名称
    private static String q2 = "q2";//队列
    private static String key_yeah_email = "yeah";//路由key给网易邮箱发送

    public static void main(String[] args)
    {
        //创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //设置连接对象的属性
        connectionFactory.setHost("ip");
        connectionFactory.setUsername("root");//用户名
        connectionFactory.setPassword("pwd");//密码
        connectionFactory.setPort(5672);//端口
        connectionFactory.setVirtualHost("/");//虚拟机

        //通过工厂创建连接对象
        Connection connection = null;
        try
        {
            connection = connectionFactory.newConnection();
            //创建通道
            Channel channel = connection.createChannel();
            //创建交换机
            channel.exchangeDeclare(exchange_name,BuiltinExchangeType.DIRECT);
            /**
             * 参数：
             *  1 队列名称
             *  2 是否持久化：就是重启MQ后是否存在
             *  3 是否独占连接，就是连接对象销毁后此队列是否还存在
             *  4 是否自动删除,就是空闲不用会自己删除
             *  5 通过map设置一些扩展参数
             */
            channel.queueDeclare(q2,true,false,false,null);

            //绑定队列
            channel.queueBind(q2,exchange_name,key_yeah_email);

            //消费方法
            DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
                //重写接收消息后要执行的方法
                /**
                 * @param consumerTag 标识消费者
                 * @param envelope 信封：可以拿到交换机 可以获得消息id
                 * @param properties 属性值
                 * @param body 消息内容
                 * @throws IOException
                 */
                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException
                {
                    String msg = new String(body,"utf-8");
                    System.out.println("消费者1收到消息:"+msg);
                }
            };

            // 监听队列1
            /**
             * 参数
             *  1 队列名称
             *  2 是否自动回复
             *  3 消费方法：接收到消息后需要执行的方法
             */
            channel.basicConsume(q2,true,defaultConsumer);
        } catch (IOException | TimeoutException e)
        {
            e.printStackTrace();
        } finally
        {

        }
    }
}

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EzUTKYWe-1631801852314)(https://www.heyexi.com/markdown/image-20210826211109455.png)]

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-p3kPuOSD-1631801852315)(https://www.heyexi.com/markdown/image-20210826211115492.png)]

  5. topic模式：将路由键和某模式进行匹配，此时队列需要绑定在一个模式上，“#”匹配一个词或多个词，“*”只匹配一个词。

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0cbNZzCX-1631801852316)(https://www.heyexi.com/markdown/image-20210826211821522.png)]

    通配符模式和路由模式是一样的，都是通过路由key进行消息队列发送，不同的是路由模式是将路由key进行相等判断匹配，而通配符是根据通配符进行匹配。

    每个路由直接通过.来分隔，通配符有#和*,#匹配单个或多个单词，*匹配一个单词

    #: com.#可以匹配 com.heyexi com.libai com.heyexi.pojo
*: com.*可以匹配 com.heyexi com.libai 不能匹配:com.heyexi.pojo

    代码和路由模式一样，唯一要改的就是在绑定队列和路由时的路由Key换成通配符，在发送消息时选择具体的路由Key，它会去匹配上面队列和交换机绑定的通配符模式。哦，还有要改交换机的类型。

  6. header模式

    header模式与routing不同的地方在于，header模式取消routingkey，使用header中的 key/value（键值对）匹配队列。

SpringBoot集成RabbitMQ

现在使用SpringBoot来集成一下消息队列，首先添加依赖，因为是基于AMQP协议，所以需要先添加这个，版本选择自动继承。

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

和Springboot集成的项目都可以在配置文件中配置，那我们这个Rabbit的连接信息也可以在那里配置

server:
  port: 8090
spring:
  rabbitmq:
    host: ip
    port: 5672
    username: root
    password: pwd
    virtual-host: /

然后创建一个配置类，用来声明交换机，队列之类的信息。配置就三步：

定义队列、定义交换机、绑定队列和交换机

@Configuration
public class RabbitmqConfig
{
    private String q1_name = "queue_q1";
    private String q2_name = "queue_q2";
    private String ex_name = "exchange_ex";
    private String key1 = "qq";
    private String key2 = "yeah";

    //1.定义队列
    @Bean
    public Queue q1()
    {
        return new Queue(q1_name);
    }
    @Bean
    public Queue q2()
    {
        return new Queue(q2_name);
    }

    //2.定义交换机
    @Bean
    public DirectExchange directExchange()
    {
        return new DirectExchange(ex_name);
    }
    @Bean //要使用的交换机都可以定义
    public FanoutExchange fanoutExchange()
    {
        return new FanoutExchange(ex_name);
    }

    //3.绑定交换和队列
    //这里注意：不同类型的交换机和队列的绑定方法会有所不同
    //然后就是参数名称就是上面的方法名，通过方法名找到上面的队列或者交换机
    @Bean
    Binding bindingExQueue(Queue q1,DirectExchange directExchange)
    {
        return BindingBuilder.bind(q1).to(directExchange).with(key1);
    }
    @Bean
    Binding bindingExQueue2(Queue q2,DirectExchange directExchange)
    {
        return BindingBuilder.bind(q2).to(directExchange).with(key2);
    }
}

然后创建生产者，生产者就负责发送消息，发送的方法可以通过amqpTemplate这个来发送，只是交换机不同里面参数不一样而已，和原始参数是一样的，可以下载源码查看不同的交换机的发送参数这里使用的是路由交换机的发送。

/**
 * 生产者
 */
@Component
public class BootRouterProducer
{
    @Autowired
    private AmqpTemplate amqpTemplate;
    @Autowired
    private RabbitmqConfig rabbitmqConfig;

    /**
     * 发送消息方法
     */
    public void sendMsg(String msg,String rourtingKey)
    {
        System.out.println("给"+rourtingKey+"队列发送:");
        //发送消息
        amqpTemplate.convertAndSend(rabbitmqConfig.directExchange().getName(),rourtingKey,msg);
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fyUyEzpd-1631801852318)(https://www.heyexi.com/markdown/image-20210827183608446.png)]

然后定义消费者，消费者很简单，使用RabbitListener注解指定要监听的队列名，使用RabbitHandler注解在代表收到生产者的信息时，会执行这个方法，我们可以在这里对数据进行处理，就算程序结束消息没接收完，那么下次重启程序还是会执行这里把消息接受完，这个方法是很重要的。

/**
 * 监听Q1队列的消费者
 */
@Component
@RabbitListener(queues = "queue_q1") //这个注解代表监听队列
public class BootConsumerQ1
{
    @RabbitHandler //使用这个注解代表监听方法
    public void process(String msg)
    {
        System.out.println("消费者1收到消息:"+msg);
    }
}

最后定义一个控制器来发送消息，我们可以在实际项目做做成一个发送消息的方法，那么就是一旦发送就会在消费者方法中收到消息，进行通知用户的的处理。

@RestController
public class SendMsgController
{
    @Autowired
    private BootRouterProducer bootRouterProducer;

    @GetMapping("/sendMsg")
    public String sendMsg(String msg,String routingkey)
    {
        bootRouterProducer.sendMsg(msg,routingkey);
        return "ok";
    }
}

image-20210827190737925

image-20210827190800202

image-20210827191100754

何夜息
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringBoot快速入门单纯的SPringBoot项目
05-23
**SpringBoot快速入门** SpringBoot是由Pivotal团队提供的全新框架，其设计目标是为了简化Spring应用的初始搭建以及开发过程。它集成了大量的常用组件，如数据源、JPA、定时任务、WebSocket等，使得开发者可以快速...
springboot从入门到精通
08-08
本资源包"springboot从入门到精通"旨在帮助初学者和进阶者全面掌握SpringBoot的核心概念和技术。 一、SpringBoot基础 SpringBoot的基础部分涵盖了如何创建第一个SpringBoot项目，通过起步依赖（Starters）简化Maven...
SpringBoot集成RabbitMq
Blueeyedboy521的博客
04-07 8242
一、初识MQ RabbitMQ是一个开源的消息代理和队列服务器，用来通过普通协议在完全不同的应用之间共享数据，RabbitMQ是使用Erlang语言来编写的，并且是基于AMQP协议的。 AMQP：Advanced Message Queuing Protocol，高级消息队列协议。是具有现代特征的二进制协议，是一个提供统一消息服务的应用层标准高级消息队列协议，是应用层协议的一个开放标准，为面向消息的中间件设计。 1、同步调用的问题 2、异步调用方案 优势一：服务解耦 优势二：性能提升，吞吐量提高 优势三
SpringBoot RabbitMQ 入门学习（详细）
qq_37280924的博客
05-25 1513
目录安装 RabbitMQ初始化 SpringBoot 项目导入依赖添加配置配置文件 application.yml添加配置类 RabbitMqConfig简单队列发送者消费者测试类测试的 Controller单元测试类运行路由（交换机）创建一个交换机（Exchange）交换机与队列的绑定Topic Exchange修改 `Sender` 类的 `send` 方法测试Headers Exchange 自定义规则Fanout Exchange 订阅模式创建订阅交换机消失丢失开启RabbitMQ的数据持久化参考
「RabbitMQ入门三」SpringBoot2.1.5 集成RabbitMQ
Java猿人一枚的博客
07-16 717
「RabbitMQ入门三」SpringBoot2.1.5 集成RabbitMQ一、修改配置二、依赖添加三、配置添加四、rabbitmq配置类五、sender和receiver类六、springboot test测试 一、修改配置 本文springboot集成rabbitmq用的是它自带的guest账户，一般guest是不允许远程连接的，所以呢，我们先修改下配置 cd /usr/local/rab...
SpringBoot如何整合RabbitMQ
热门推荐
ShuSheng007的程序人生
07-23 1万+
好久没有写博客了，终日忙于生计，真是人过30不如狗啊，但写点什么好呢？想想当年自己入门时候那痛苦的经历，还是写点优质实用的入门文章吧，既满足了自己好为人师的本性，也能给后辈提供一些帮助。今天咱们就来聊聊springboot整合rabbitmq的那些事吧。SpringBoot的风头之盛不多说了，我是在2016年首次接触springboot的，当时自己要写个APP，后台采用了springboot。当时还真是个新鲜事物，没想到以后几年的发展犹如黄河泛滥，一发不可收拾…rabbitmq官网https。...
SpringBoot 集成 RabbitMQ（上）
sco5282的博客
09-26 1878
接下来使用 SpringBoot 来集成 RabbitMQ 1. 简单模式
SpringBoot2整合RabbitMQ入门
冷兮Coding
05-09 1087
一、消息队列概述 1. 消息服务中两个重要概念： 消息代理（message broker）和 目的地（Destination） 当消息发送者发出消息以后，将由消息代理接管，消息代理保证消息传递到指定目的地。 2. 消息队列主要有两种形式的目的地 1. 队列（queue）: 点对点消息通信（point-to-point） 2. 主题（topic）: 发布（publish）/ 订阅（subscribe）消息通信 点对点式 消息发送者发送消息，消息代理将其放入一个队列中，消息接收者从队列中获取消息内容，消息读
【RabbitMQ快速入门(二、Springboot集成RabbitMQ(详细步骤配置))】
xyhxuyonghao的博客
03-20 914
Springboot集成RabbitMQ
rabbitmq详细入门文档+springboot结合使用
jingke_1524的博客
09-23 910
在介绍RabbitMQ之前，我们先来看下面一个电商项目的场景： 商品的原始数据保存在数据库中，增删改查都在数据库中完成。 搜索服务数据来源是索引库（Elasticsearch），如果数据库商品发生变化，索引库数据不能及时更新。 商品详情做了页面静态化处理，静态页面数据也不会随着数据库商品更新而变化。 如果我们在后台修改了商品的价格，搜索页面和商品详情页显示的依然是旧的价格，这样显然不对。该如何解决？ 我们可能会想到这么做： 方案1：每当后台对商品做增删改操作，同时修.
RabbitMQ高级特性整合SpringBoot注解版入门笔记
hrdate(菜菜菜带带带)
12-02 1014
本篇的rabbitmq基本的高级特性整合SpringBoot注解版入门笔记包括：1. 消息的可靠投递 2. Consumer Ack 3. 消费端限流 4. TTL5. 死信队列DLX 6. 延迟队列 7. 日志与监控 8. 消息追踪
springboot入门项目
08-01
它集成了大量常用的第三方库配置，如 JDBC、MongoDB、JPA、RabbitMQ、Quartz 等，使得开发者可以快速地创建一个独立运行的、生产级别的基于 Spring 的应用。 在“springboot入门项目”中，我们可以看到这是一个为...
rabbitMQ课件.zip
10-26
在RabbitMQ入门阶段，你需要了解以下几个核心概念： 1. **生产者（Producer）**: 发送消息的应用程序。 2. **消费者（Consumer）**: 接收并处理消息的应用程序。 3. **交换机（Exchange）**: 分发消息的路由器，...
springboot-rabbitmq：springboot-rabbitmq学习与实践项目
02-14
项目须知项目包括springboot集成rabbitmq入门和实战，stater包下是入门代码，practice1下面是实战代码starter内包括的是基本的springboot集合rabbitMq的使用练习内包含：秒杀场景兔MQ死信量子兔MQ
Docker-安装MongoDB、RabbitMQ、ActiveMQ、Portainer（保姆篇图示详解）
A的博客
07-09 1049
将图示的admim/或者user账号 修改成自己想要的账号密码即可------根据镜像 运行容器实例 （暴露端口 数据挂载 用户密码设置等）访问测试，点击Manage ActiveMQ broker,测试连接，我是用的是MongoDB Compass进行连接。如果想要修改密码，则继续看（否则跳过这部分内容即可）拉取镜像（默认为最新版本，也可指定版本）拉取镜像(ActiveMQ 还有一个镜像。输入账号密码为admin/admin。使用默认guest账户 /密码登录。
百日筑基第二十天-一头扎进消息队列3-RabbitMQ
最新发布
qq_45477639的博客
07-13 1343
RabbitMQ 主要有 Producer、Broker、Consumer、Exchange、Queue、Route、Bind、 Connection、Channel、ACK 等概念。总结 RabbitMQ，可以从以下七个方面入手：思考题 请你按照基础篇的课程思路，完整描述一下 RabbitMQ 从生产到消费的全过程？协议层基于 AMQP 标准开发。网络层核心数据流基于 TCP 协议通信，并通过 Connection 和 Channel 机制实现连接的复 用，以减少创建的 TCP 连接数量。
Elsaticsearch java基本操作
qq_62383709的博客
07-13 357
索引 基本操作 package com.orchids.elasticsearch.web.controller; import cn.hutool.core.collection.CollUtil; import cn.hutool.json.JSONUtil; import com.orchids.elasticsearch.web.po.User; import io.swagger.annotations.Api; import io.swagger.annotations.ApiOperatio
java版的上门家政系统和PHP版的上门家政有什么区别？
baina666的博客
07-12 384
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值