RabbitMQ了解——＞安装——＞入门

最新推荐文章于 2024-05-25 19:51:54 发布
最新推荐文章于 2024-05-25 19:51:54 发布
阅读量252 收藏 2
点赞数 1
文章标签： java rabbitmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CxnKh/article/details/116028578
版权

1. 正文–rabbitMQ–消息中间件

1. 什么MQ?
2. MQ的优缺点
3. 常见的MQ有哪些？
4. 什么是rabbitMQ？
5. RabbitMQ的结构？
6. RabbitMQ的安装？
7. RabbitMQ的五种模式？
（1）简单模式
（2）工作者模式: 
（3）发布订阅模式
（4）路由模式
（5）topic主体模式。
8. Springboot整合rabbitMQ

2.什么MQ?

MQ全称 Message Queue（消息队列），是在消息的传输过程中保存消息的容器。多用于分布式系统之间进行通信。

3. MQ的优缺点

优点:

应用解耦：提高系统容错性和可维护性
异步提速：提升用户体验和系统吞吐量
削峰填谷：提高系统稳定性

缺点:

系统可用性降低
系统引入的外部依赖越多，系统稳定性越差。一旦 MQ 宕机，就会对业务造成影响。如何保证MQ的高可用？
系统复杂度提高
MQ 的加入大大增加了系统的复杂度，以前系统间是同步的远程调用，现在是通过 MQ 进行异步调用。如何保证消息没有被重复消费？怎么处理消息丢失情况？那么保证消息传递的顺序性？

一致性问题
A 系统处理完业务，通过 MQ 给B、C、D三个系统发消息数据，如果 B 系统、C 系统处理成功，D 系统处理失败。如何保证消息数据处理的一致性？

4. 常见的MQ有哪些？

在这里插入图片描述

5. 安装rabbitMQ

1. 上传安装软件(1.erlang   2.rabbitmq)
2. 安装rabbitmq依赖的环境
    yum install -y gcc  socat  openssl  openssl-devel
    
3. 安装erlang 和 rabbitMQ
   rpm -ivh erlang-22.0.7-1.el7.x86_64.rpm
   rpm -ivh rabbitmq-server-3.7.17-1.el7.noarch.rpm
   
4. 开启管理界面及配置  ---理解为图形化界面
rabbitmq-plugins enable rabbitmq_management
开设一个用户用来访问rabbitMQ
 进入rabbitMQ的配置目录
 cd /usr/share/doc/rabbitmq-server-3.7.17
 cp rabbitmq.config.example /etc/rabbitmq/rabbitmq.config

在这里插入图片描述

在这里插入图片描述

5. 开启rabbitMQ服务器。
systemctl start rabbitmq-server

6. systemctl restart rabbitmq-server 重启

在这里插入图片描述

在这里插入图片描述

6. rabbitMQ的结构以及每个组件的作用

在这里插入图片描述

Broker：接收和分发消息的应用，RabbitMQ Server就是 Message Broker

Virtual host：出于多租户和安全因素设计的，把 AMQP 的基本组件划分到一个虚拟的分组中，类似于网络中的 namespace 概念。当多个不同的用户使用同一个 RabbitMQ server 提供的服务时，可以划分出多个vhost，每个用户在自己的 vhost 创建 exchange／queue 等

Connection：publisher／consumer 和 broker 之间的 TCP 连接

Channel：如果每一次访问 RabbitMQ 都建立一个 Connection，在消息量大的时候建立 TCP Connection的开销将是巨大的，效率也较低。Channel 是在 connection 内部建立的逻辑连接，如果应用程序支持多线程，通常每个thread创建单独的 channel 进行通讯，AMQP method 包含了channel id 帮助客户端和message broker 识别 channel，所以 channel 之间是完全隔离的。Channel 作为轻量级的 Connection 极大减少了操作系统建立 TCP connection 的开销

Exchange：message 到达 broker 的第一站，根据分发规则，匹配查询表中的 routing key，分发消息到queue 中去。常用的类型有：direct (point-to-point), topic (publish-subscribe) and fanout (multicast)

Queue：消息最终被送到这里等待 consumer 取走

Binding：exchange 和 queue 之间的虚拟连接，binding 中可以包含 routing key。Binding 信息被保存到 exchange 中的查询表中，用于 message 的分发依据

7. rabbitMQ的模式

（1）简单模式

在这里插入图片描述

从图上可以看到只有三个角色:
   p 【product】: 生产者  发生消息的
   红色[queue]: 队列。  存储消息的
   C [consumer]: 消费者  消费消息

生产者的代码:

package com.kh;

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

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class hello {
    public static void main(String[] args) {
        //创建链接工厂 --配置连接信息
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.31.98");

        Connection connection= null;
        Channel channel = null;
        try {
            //创建连接对象Connection
            connection = factory.newConnection();
            //创建信道
            channel = connection.createChannel();
        } catch (Exception e) {
            e.printStackTrace();
        }
        //创建队列
        /**
         * String queue,队列的名称
         * boolean durable,是否持久化 rabbitMQ服务器重启以后该存放是否还存在
         * boolean exclusive,是否独占false
         * boolean autoDelete,是否自动删除（如果长时间没有发送消息 则自动删除）
         * Map<String, Object> arguments  额外参数 先给null
         */
        try {
            channel.queueDeclare("kh_queue",true,false,false,null);
        } catch (IOException e) {
            e.printStackTrace();
        }
        //发送信息
        /**
         * String exchange,交换机的名称 如果没有就选择"" 它会自动选择默认
         * String routingKey,路由key  如果没有交换机的绑定 使用队列的名称
         * BasicProperties props,消息的一些额外配置 目前先不加 null
         * byte[] body 消息的内容
         */
        String msg="孔昊加油！！";
        try {
            channel.basicPublish("","kh_queue",null,msg.getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

消费者代码:

package com.kh.hello;

import com.rabbitmq.client.*;

import java.io.IOException;



public class Consumer {
    public static void main(String[] args)  {
        //创建链接工厂 --配置连接信息
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.31.98");

        Connection connection= null;
        Channel channel = null;
        try {
            //创建连接对象Connection
            connection = factory.newConnection();
            //创建信道
            channel = connection.createChannel();
        } catch (Exception e) {
            e.printStackTrace();
        }
        //接收信息
        /**
         *  String consumerTag,消费者标签
         *  Envelope envelope, 信封
         *  AMQP.BasicProperties properties,
         *  byte[] body
         */
        DefaultConsumer callback = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //body: 接受的信息
                System.out.println("消息的内容："+new String(body));
            }
        };


            /*
             *  String queue, 队列的名称
             *  boolean autoAck, 是否自动确认
             *  Consumer callback： 回调方法 当队列中存在信息后 会自动触发回调函数
             */
        try {
            channel.basicConsume("kh_queue",true,callback);
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

（2）工作者模式

在这里插入图片描述

特点:
    1. 一个生产者
    2. 由多个消费。
    3. 统一个队列。
    4. 这些消费者之间存在竞争关系。

用处:
    比如批量处理上. rabbitMQ里面积压了大量的消息。

生产者

package com.kh;

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

import java.io.IOException;
public class work {
    public static void main(String[] args) {
        //创建链接工厂 --配置连接信息
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.31.98");

        Connection connection= null;
        Channel channel = null;
        try {
            //创建连接对象Connection
            connection = factory.newConnection();
            //创建信道
            channel = connection.createChannel();
        } catch (Exception e) {
            e.printStackTrace();
        }

        //创建队列
        /**
         * String queue, 队列的名称
         * boolean durable, 是否该队列持久化 rabbitMQ服务重启后该存放是否存在。
         * boolean exclusive, 是否独占 false
         * boolean autoDelete, 是否自动删除  如果长时间没有发生消息 则自动删除
         * Map<String, Object> arguments 额外参数  先给null
         */
        try {
            channel.queueDeclare("kh_queue_work",true,false,false,null);
        } catch (IOException e) {
            e.printStackTrace();
        }
        //发送消息
        /**
         * String exchange,
         * String routingKey,
         * BasicProperties props,
         * byte[] body
         */

        try {
            for (int i = 1; i < 10; i++) {
                String msg="陈星霓szz！！！"+i;
                channel.basicPublish("","kh_queue_work",null,msg.getBytes());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        //生产者这里可以管理资源  消费者不能关闭资源。
        try {
            channel.close();
            connection.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

消费者01：

package com.kh.work;

import com.rabbitmq.client.*;

import java.io.IOException;

public class Consumer01 {
    public static void main(String[] args) {
        //创建链接工厂 --配置连接信息
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.31.98");

        Connection connection= null;
        Channel channel = null;
        try {
            //创建连接对象Connection
            connection = factory.newConnection();
            //创建信道
            channel = connection.createChannel();
        } catch (Exception e) {
            e.printStackTrace();
        }
        //接收消息
        DefaultConsumer callback = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {

                System.out.println("消费者01:"+new String(body));
            }
        };
        try {
            channel.basicConsume("kh_queue_work",true,callback);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

消费者02:

package com.kh.work;

import com.rabbitmq.client.*;

import java.io.IOException;

public class Consumer02 {
    public static void main(String[] args) {
        //创建链接工厂 --配置连接信息
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.31.98");

        Connection connection= null;
        Channel channel = null;
        try {
            //创建连接对象Connection
            connection = factory.newConnection();
            //创建信道
            channel = connection.createChannel();
        } catch (Exception e) {
            e.printStackTrace();
        }
        //接收消息
        DefaultConsumer callback = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {

                System.out.println("消费者02:"+new String(body));
            }
        };
        try {
            channel.basicConsume("kh_queue_work",true,callback);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

(3) 发布订阅模式

在这里插入图片描述

1. 特点:
    1.一个生产者
    2.多个消费者
    3.多个队列。
    4.交换机 转发消息。

生产者:

package com.kh;

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

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class fanout {
    public static void main(String[] args) {
        //创建链接工厂 --配置连接信息
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.31.98");

        Connection connection= null;
        Channel channel = null;
        try {
            //创建连接对象Connection
            connection = factory.newConnection();
            //创建信道
            channel = connection.createChannel();
        } catch (Exception e) {
            e.printStackTrace();
        }
        //创建队列
        /**
         * String queue, 队列的名称
         * boolean durable, 是否该队列持久化 rabbitMQ服务重启后该存放是否存在。
         * boolean exclusive, 是否独占 false
         * boolean autoDelete, 是否自动删除  如果长时间没有发生消息 则自动删除
         * Map<String, Object> arguments 额外参数  先给null
         */
        try {
            channel.queueDeclare("kh_queue_fanout01",true,false,false,null);
            channel.queueDeclare("kh_queue_fanout02",true,false,false,null);
        } catch (Exception e) {
            e.printStackTrace();
        }
        //创建交换机
        /**
         * String exchange,交换机的名称
         * BuiltinExchangeType type, 交换机的类型
         * boolean durable:是否持久化
         */
        try {
            channel.exchangeDeclare("kh_exchange", BuiltinExchangeType.FANOUT,true);
        } catch (Exception e) {
            e.printStackTrace();
        }
        //绑定交换机与队列
        /**
         * String queue,  队列名
         * String exchange, 交换机的名称
         * String routingKey:路由key 如果交换机为fanout模式则不需要路由key
         */
        try {
            channel.queueBind("kh_queue_fanout01","kh_exchange","");
            channel.queueBind("kh_queue_fanout02","kh_exchange","");
        } catch (Exception e) {
            e.printStackTrace();
        }

        try {
            for (int i = 0; i <= 10; i++) {
                String msg = "khszz";
                channel.basicPublish("kh_exchange", "", null, msg.getBytes());
            }
        }catch (IOException e) {
            e.printStackTrace();
        }
        //生产者这里可以管理资源  消费者不能关闭资源。
        try {
            channel.close();
            connection.close();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
    }
}

消费者01代码:

package com.kh.fanout;

import com.rabbitmq.client.*;

import java.io.IOException;

public class Consumer01 {
    public static void main(String[] args) {
        //创建链接工厂 --配置连接信息
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.31.98");

        Connection connection= null;
        Channel channel = null;
        try {
            //创建连接对象Connection
            connection = factory.newConnection();
            //创建信道
            channel = connection.createChannel();
        } catch (Exception e) {
            e.printStackTrace();
        }
        //接受消息
        /**
         * (String queue, 队列的名称
         *  boolean autoAck, 是否自动确认
         *  Consumer callback： 回调方法 当队列中存在信息后 会自动触发回调函数。
         */
        DefaultConsumer callback=new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //body 接受的信息
                System.out.println("消费者01:"+new String(body));
            }
        };
        try {
            channel.basicConsume("kh_queue_fanout01",true,callback);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

消费者02代码

package com.kh.fanout;

import com.rabbitmq.client.*;

import java.io.IOException;


public class Consumer02 {
    public static void main(String[] args)  {
        //创建链接工厂 --配置连接信息
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.31.98");

        Connection connection= null;
        Channel channel = null;
        try {
            //创建连接对象Connection
            connection = factory.newConnection();
            //创建信道
            channel = connection.createChannel();
        } catch (Exception e) {
            e.printStackTrace();
        }
        //接收信息
        /**
         *  String consumerTag,消费者标签
         *  Envelope envelope, 信封
         *  AMQP.BasicProperties properties,
         *  byte[] body
         */
        DefaultConsumer callback = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //body: 接受的信息
                System.out.println("消息的内容："+new String(body));
            }
        };

            /*
             *  String queue, 队列的名称
             *  boolean autoAck, 是否自动确认
             *  Consumer callback： 回调方法 当队列中存在信息后 会自动触发回调函数
             */
        try {
            channel.basicConsume("kh_queue_fanout02",true,callback);
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

（4）路由模式

在这里插入图片描述

特点:
    1.一个生产者
    2.多个消费者
    3.多个队列。
    4.交换机 转发消息。
    5.routekey:路由key 只要routekey匹配的消息可以到达对应队列。

package com.kh;

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

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class LuYou {
    public static void main(String[] args) {
        //创建链接工厂 --配置连接信息
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.31.98");

        Connection connection= null;
        Channel channel = null;
        try {
            //创建连接对象Connection
            connection = factory.newConnection();
            //创建信道
            channel = connection.createChannel();
        } catch (Exception e) {
            e.printStackTrace();
        }
        //创建队列
        /**
         * String queue, 队列的名称
         * boolean durable, 是否该队列持久化 rabbitMQ服务重启后该存放是否存在。
         * boolean exclusive, 是否独占 false
         * boolean autoDelete, 是否自动删除  如果长时间没有发生消息 则自动删除
         * Map<String, Object> arguments 额外参数  先给null
         */
        try {
            channel.queueDeclare("kh_queue_Luyou01",true,false,false,null);
            channel.queueDeclare("kh_queue_Luyou02",true,false,false,null);
        } catch (IOException e) {
            e.printStackTrace();
        }
        //创建交换机
        /**
         * String exchange,交换机的名称
         * BuiltinExchangeType type, 交换机的类型
         * boolean durable:是否持久化
         */
        try {
            channel.exchangeDeclare("kh_exchange_Luyou", BuiltinExchangeType.DIRECT,true);
        } catch (IOException e) {
            e.printStackTrace();
        }
        //绑定交换机与队列
        /**
         * String queue,  队列名
         * String exchange, 交换机的名称
         * String routingKey:路由key 如果交换机为fanout模式则不需要路由key
         */
        try {
            channel.queueBind("kh_queue_Luyou01","kh_exchange_Luyou","error");
            channel.queueBind("kh_queue_Luyou02","kh_exchange_Luyou","info");
            channel.queueBind("kh_queue_Luyou02","kh_exchange_Luyou","error");
            channel.queueBind("kh_queue_Luyou02","kh_exchange_Luyou","warning");
        } catch (IOException e) {
            e.printStackTrace();
        }
        //发生消息
        /**
         * String exchange: 交换机的名称 如果没有则使用“” 它回自动采用默认
         * String routingKey, 路由key  如果没有交换机的绑定 使用队列的名称
         * BasicProperties props, 消息的一些额外配置 目前先不加 null
         * byte[] body 消息的内容
         */
        try {
            for (int i = 0; i <= 10; i++) {
                String msg = "khszz";
                channel.basicPublish("kh_exchange_Luyou", "info", null, msg.getBytes());
            }
        }catch (IOException e) {
            e.printStackTrace();
        }
        //生产者这里可以管理资源  消费者不能关闭资源。
        try {
            channel.close();
            connection.close();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
    }
}

（5）topic主体模式
在这里插入图片描述

1. 绑定按照通配符的模式。
     *: 统配一个单词。
     #: 统配n个单词

hello.orange.rabbit

lazy.orange

生产者：

package com.kh;

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

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Topic {
    public static void main(String[] args) {
        //创建链接工厂 --配置连接信息
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.31.98");

        Connection connection= null;
        Channel channel = null;
        try {
            //创建连接对象Connection
            connection = factory.newConnection();
            //创建信道
            channel = connection.createChannel();
        } catch (Exception e) {
            e.printStackTrace();
        }
        //创建队列
        /**
         * String queue, 队列的名称
         * boolean durable, 是否该队列持久化 rabbitMQ服务重启后该存放是否存在。
         * boolean exclusive, 是否独占 false
         * boolean autoDelete, 是否自动删除  如果长时间没有发生消息 则自动删除
         * Map<String, Object> arguments 额外参数  先给null
         */
        try {
            channel.queueDeclare("kh_queue_Topic01",true,false,false,null);
            channel.queueDeclare("kh_queue_Topic02",true,false,false,null);
        } catch (IOException e) {
            e.printStackTrace();
        }
        //创建交换机
        /**
         * String exchange,交换机的名称
         * BuiltinExchangeType type, 交换机的类型
         * boolean durable:是否持久化
         */
        try {
            channel.exchangeDeclare("kh_exchange_Topic", BuiltinExchangeType.TOPIC,true);
        } catch (IOException e) {
            e.printStackTrace();
        }
        //绑定交换机与队列
        /**
         * String queue,  队列名
         * String exchange, 交换机的名称
         * String routingKey:路由key 如果交换机为fanout模式则不需要路由key
         */
        try {
            channel.queueBind("kh_queue_Topic01","kh_exchange_Topic","*.orange.*");
            channel.queueBind("kh_queue_Topic02","kh_exchange_Topic","*.*.rabbit");
            channel.queueBind("kh_queue_Topic02","kh_exchange_Topic","lazy.#");
        } catch (IOException e) {
            e.printStackTrace();
        }
        //发生消息
        /**
         * String exchange: 交换机的名称 如果没有则使用“” 它回自动采用默认
         * String routingKey, 路由key  如果没有交换机的绑定 使用队列的名称
         * BasicProperties props, 消息的一些额外配置 目前先不加 null
         * byte[] body 消息的内容
         */
        try {
            for (int i = 0; i <= 10; i++) {
                String msg = "cxnszz";
                channel.basicPublish("kh_exchange_Topic", "lazy.orange.rabbit", null, msg.getBytes());
            }
        }catch (IOException e) {
            e.printStackTrace();
        }
        //生产者这里可以管理资源  消费者不能关闭资源。
        try {
            channel.close();
            connection.close();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
    }
}

消费者01代码：

package com.kh.topic;

import com.rabbitmq.client.*;

import java.io.IOException;

public class Consumer01 {
    public static void main(String[] args) {
        //创建链接工厂 --配置连接信息
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.31.98");

        Connection connection= null;
        Channel channel = null;
        try {
            //创建连接对象Connection
            connection = factory.newConnection();
            //创建信道
            channel = connection.createChannel();
        } catch (Exception e) {
            e.printStackTrace();
        }
        //接受消息
        /**
         * (String queue, 队列的名称
         *  boolean autoAck, 是否自动确认
         *  Consumer callback： 回调方法 当队列中存在信息后 会自动触发回调函数。
         */
        DefaultConsumer callback=new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //body 接受的信息
                System.out.println("消费者01:"+new String(body));
            }
        };
        try {
            /*
             *  String queue, 队列的名称
             *  boolean autoAck, 是否自动确认
             *  Consumer callback： 回调方法 当队列中存在信息后 会自动触发回调函数
             */
            channel.basicConsume("kh_queue_Topic01",true,callback);
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

消费者02代码

package com.kh.topic;

import com.rabbitmq.client.*;

import java.io.IOException;

public class Consumer02 {
    public static void main(String[] args) {
        //创建链接工厂 --配置连接信息
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.31.98");

        Connection connection= null;
        Channel channel = null;
        try {
            //创建连接对象Connection
            connection = factory.newConnection();
            //创建信道
            channel = connection.createChannel();
        } catch (Exception e) {
            e.printStackTrace();
        }
        //接受消息
        /**
         * (String queue, 队列的名称
         *  boolean autoAck, 是否自动确认
         *  Consumer callback： 回调方法 当队列中存在信息后 会自动触发回调函数。
         */
        DefaultConsumer callback=new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //body 接受的信息
                System.out.println("消费者01:"+new String(body));
            }
        };
        try {
            /*
             *  String queue, 队列的名称
             *  boolean autoAck, 是否自动确认
             *  Consumer callback： 回调方法 当队列中存在信息后 会自动触发回调函数
             */
            channel.basicConsume("kh_queue_Topic02",true,callback);
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

8.springboot整合RamubbitMQ

目录结构：
在这里插入图片描述
springboot引入了相关的依赖后，提供一个工具类RabbitTemplate.使用这个工具类可以发送消息。

（1）父工程引入依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <packaging>pom</packaging>
    <modules>
        <module>product</module>
        <module>consumer</module>
        <module>Consumer01</module>
    </modules>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.4.5</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.kh</groupId>
    <artifactId>spring-boot-rabbit</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>spring-boot-rabbit</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <!--Rabbit依赖 启动类加载 读取配置文件：
            springboot自动装配原理： 引用starter启动依赖时，把对应的自动装配类加载进去，
            该自动加载装配类可以读取application配置文件中的内容 DispatherServlet
        -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
        <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>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.amqp</groupId>
            <artifactId>spring-rabbit-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.72</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

（2）相应的生产者和消费的配置

server:
  port: 8888
#rabbit的配置
spring:
  rabbitmq:
    host: 192.168.31.98

（3）生产者代码

package com.kh

import com.alibaba.fastjson.JSON;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.HashMap;
import java.util.Map;


@RestController
public class HelloController {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @GetMapping("hello")
    public String hello(){ //业务层
        System.out.println("下单成功");
        //String exchange, String routingKey, Object message
        Map<String,Object> map=new HashMap<>();
        map.put("productId",1);
        map.put("num",10);
        map.put("price",12);
        rabbitTemplate.convertAndSend("ban129_exchange","", JSON.toJSONString(map)); //序列化过程
        return "下单成功";
    }
}

（4）监听者代码

package com.kh.listen

import com.alibaba.fastjson.JSON;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.Map;

/**
 * @Author 闫克起
 * @Date 2021/4/20 17:06
 * @Version 1.0
 */
@Component
public class MyRabbitListener {

    //队列中存在消息则立即回调该方法
    @RabbitListener(queues = {"ban129_queue_fanout01"})
    public void listener(String msg){
        Map map = JSON.parseObject(msg, Map.class);
        System.out.println(map);
    }

   
}
超想你呢
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Linux中安装RabbitMQ急速入门.md
11-26
Linux中安装RabbitMQ急速入门，快速安装，纯小白可直接上手，内容详细步骤明确，只要按照文档中来操作，成功率100%
RabbitMQ--基础入门
shi_AXing_a的博客
04-21 229
RabbitMQ基础入门1. 什么MQ?2、MQ的优缺点 1. 什么MQ? MQ全称 Message Queue（消息队列），是在消息的传输过程中保存消息的容器。多用于分布式系统之间进行通信。 2、MQ的优缺点 优点 1、 应用解耦：提高系统容错性和可维护性 假设有这样一个场景, 服务A产生数据, 而服务B,C,D需要这些数据, 那么我们可以在A服务中直接调用B,C,D服务,把数据传递到下游服务即可 但是,随着我们的应用规模不断扩大,会有更多的服务需要A的数据,如果有几十甚至几百个下游服务,而且会不断变更,
RabbitMQ
qq_45518589的博客
12-29 400
RabbitMQ依赖于Erlang、socat，因此要首先安装Erlang与socat 1.RabbitMQ简介： RabbitMQ是实现了高级消息队列协议（AMQP）的开源消息代理软件（亦称面向消息的中间件）。RabbitMQ服务器是用Erlang语言编写的，而集群和故障转移是构建在开放电信平台框架上的。所有主要的编程语言均有与代理接口通讯的客户端库。 2.RabbitMQ安装依赖： 2.1 由于RabbitMQ是基于Erlang语言开发, 所以在安装RabbitMQ之前, 需要先安装Erlang ，r
RabbitMQ在java中的使用、整合
最新发布
m0_73598900的博客
05-25 1068
学习RabbitMQ作为消息队列中间件，对于理解分布式系统、异步处理、应用解耦和提高系统可扩展性非常有帮助
RabbitMq
weixin_46666822的博客
12-18 2164
消息队列 1.pom引入依赖： 引入依赖后：容器中自动配置RabbitTemplate、AmqpAdmin、CachingConnectionFactory、RabbitMessagingTemplate <!-- rabbitmq--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId
消息中间件之RabbitMQ入门讲解(二十)
MrSpirit的博客
06-04 1398
RabbitMQ在Windows上的使用1.下载安装ErlangRabbitMQ是基于AMQP协议进行通讯的，而AMQP是依赖于Erlang语言的，所以我们需要下载安装Erlang，下载完成之后会得到一个类似otp_win64_20.0.exe的文件，本次演示使用的版本是20.0的，演示版本的安装包也可以从底部的源码里面获取。2.下载安装RabbitMQ到RabbitMQ官网下载RabbitMQ的...
Rabbitmq基础
从基础到源码解析的学习记录
12-08 1265
文章目录一、RabbitMQ入门介绍1、RabbitMQ的工作原理二、RabbitMQ五种消息发送模式1、简单队列模式2、工作队列模式2.1、轮询分发（公平分发）2.2、能者多劳（不公平分发）3、发布订阅模式4、路由模型模式5、主题模式 一、RabbitMQ入门介绍 1、RabbitMQ的工作原理 组成部分说明： Broker：消息队列服务进程，此进程包括两个部分：Exchange和Queue Exchange：消息队列交换机，按一定的规则将消息路由转发到某个队列，对消息进行过虑 Queue：消息队列，
linux安装RabbitMQ详细教程
09-15
主要介绍了linux安装RabbitMQ详细教程,需要的朋友可以参考下
rabbitmq安装教程
07-11
rabbitmq消息队列在做项目中是比较常用的，在生活中也经常用到，“生产者”和“消费者”就像我们生活中用到的美团外卖，我们下的订单就如生产者，卖家接的单就如消费者
MQ消息队列之——RabbitMQ
06-01
学习RabbitMQ的学习笔记
RabbitMq安装包及超详细安装教程
04-07
RabbitMQ 是一个由 Erlang 语言开发的 AMQP 的开源实现，此附件包含RabbitMq相关安装包及超详细安装教程，可完美解决RabbitMq安装与配置问题
ActiveMQ 基础到进阶 && 高级面试
村里的原振侠的博客
09-17 562
activemq查漏补缺 基础 带日志自定义启动 ./activemq start > /myactiveMQ/run_time.log 注意如果启动不了amq，有一种原因是：linux机器名带有下滑线_，腾讯云服务器也会带下划线，会在日志中报错。 activemq图解 通过ConnectionFactory获取connection，connection生成Session，然后session可以生成Message，MessageProducer和MessageConsumer。 消费者 一个生产者
RabbitMQ 基础篇 | 黑马
weixin_54232666的博客
04-10 796
黑马课程学习笔记，一篇彻底入门RabbitMQ，MQ的基本概念和工作模式和springboot整合rabbitMQ的用法。这一篇就够了！
RabbitMQ基本使用详解及示例
OceanSky的专栏
10-19 1万+
RabbitMQ简介 AMQP,即Advanced Message Queuing Protocol,高级消息队列协议，是应用层协议的一个开放标准，为面向消息的中间件设计。消息中间件主要用于组件之间的解耦，消息的发送者无需知道消息使用者的存在，反之亦然。AMQP的主要特征是面向消息、队列、路由（包括点对点和发布订阅）、可靠性、安全。RabbitMQ是一个开源的AMQP实现，服务端用Erlang语言...
02 RabbitMQ基础
Java是世界上最好的语言
12-18 2077
TD
RabbitMQ消息中间件快速入门
欢迎来到编程小栈
07-19 2235
文章目录一、同步和异步通讯1. 同步通讯2. 异步通讯二、RabbitMQ1. MessageQueue对比2. RabbitMQ快速入门【1】安装与启动【2】基本结构3. 五种消息模型介绍【1】入门案例1）publisher实现2）consumer实现4. SpringAMQP实现【1】Basic Queue 基本消息队列1）消息发送2）消息接收3）测试【2】WorkQueue工作消息队列1）消息发送2）消息接收3）测试4）prefetch提前获取【3】发布订阅三种模式1）Fanout[1] 声明队列和交
RabbitMQ安装以及入门
weixin_45535519的博客
12-29 539
RabbitMQ介绍； RabbitMQ安装；RabbitMQ常用命令
深入浅出Spring Boot整合RocketMQ
CERTAINTY的博客
08-09 5235
深入浅出Spring Boot整合RocketMQ
01、RabbitMQ入门
热门推荐
全栈
12-05 1万+
目录1.、什么是MQ2、应用场景 3、主流MQ框架4、Docker安装部署RabbitMQ 5、RabbitMQ管理平台6、MQ的核心概念单一生产者和单一消费者7、springboot整合rabbitmq执行测试方法testRabbitmq，控制台输出：receive msg : test rabbitmq message !!! 1.安装好rabbitmq，登陆RabbitMQ管理平台，新增管理用户并设置权限 2.pom.xml添加rabbitmq依赖 3.rabbitmq连接配置 4.创建
telnet <RabbitMQ服务器地址> 5672
12-02
2. 输入以下命令，其中<RabbitMQ服务器地址>是RabbitMQ服务器的IP地址或主机名： ``` telnet <RabbitMQ服务器地址> 5672 ``` 3. 如果连接成功，则会显示一些字符，表示连接已建立。如果连接失败，则会显示一条错误...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值