栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

RabbitMQ 笔记

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

RabbitMQ 笔记

RabbitMQ笔记

视频地址:https://www.bilibili.com/video/BV1pa4y1x7Kc?p=7&spm_id_from=pageDriver

1、介绍 1.1RabbitMQ

MQ全称为Message Queus,即消息队列,RabbitMQ是由erlang语言开发,基于AMQP(Advanced Message Queue 高级消息队列协议)协议实现的消息队列,他是一种应用程序之间的通信方法,消息队列在分布式系统开发中应用非常广泛。

开发消息队列通常有如下应用场景:

1、任务异步处理

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

2、应用程序解耦合

MQ相当于一个中介,生产方通过MQ与消费者交互,它将应用程序进行解耦合。

市场上还有哪些消息队列?

ActiceMQ、RabbitMQ、ZeroMQ、Kafka、MetaMQ、RocketMQ、Redis

为什么要使用RabbitMQ呢?

1、使用简单,功能强大。

2、基于AMQP协议。

3、社区活跃,文档完善。

4、高并发性能好,这主要的益于Erlang语言。

5、Spring Boot默认已集成RabbitMQ。

2、快速入门 2.1 RabbitMQ的工作原理

下图是RabbitMQ的基本结构:

==我的理解:==生产者(Producer)发送消息给中介(RabbitMQ)里的Excahnge(交换机),由交换机转发给指定的队列(Queue),消费者监听消息队列之后消息队列将消息转发给消费者,如果消费者还没监听,消息就存储在消息队列中。

组成部分说明如下:

  • Broker :消息队列服务进程,此进程包括两个部分: Exchange和Queue。
  • Exchange :消息队列交换机,按-定的规则将消息路由转发到某个队列,对消息进行过虑。
  • Queue :消息队列,存储消息的队列,消息到达队列并转发给指定的消费方。
  • Producer :消息生产者,即生产方客户端,生产方客户端将消费发送到MQ。
  • Consumer :消息消费者,即消费方客户端,接收MQ转发的消息。

消息发布接收流程:

———发送消息———

1、生产者和Broker建立TCP连接。

2、生产者和Broker建 立通道。

3、生产者通过通道消息发送Broker ,由Exchange将消息进行转发。

4、Exchange将消息转发到指定的Queue (队列)

———接收消息———

1、消费者和Broker建立TCP连接

2、消费者和Broker建立通道

3、消费者监听指定的Queue (队列)

4、当有消息到达Queue时Broker默认将消息推送给消费者。

5、消费者接收到消息。

2.2 hello rabbitMQ

一个生产者给一个队列发消息,一个消费者从这个队列取消息!

依赖


        
            com.rabbitmq
            amqp-client
            5.14.2
        
        
        
            org.springframework.boot
            spring-boot-starter-logging
            2.7.0
        

Producer01—生产者

package com.rabbitmq;

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 Producer01 {
    //队列
    private static final String QUEUE = "helloword2";

    public static void main(String[] args) {
        //通过连接工厂创建新的连接和mq建立连接
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("127.0.0.1");
        connectionFactory.setPort(5672);//端口
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");
        //设置虚拟机,一个mq服务可以设置多个虚拟机,每个虚拟机就相当于一个独立的mq
        connectionFactory.setVirtualHost("/");
        Connection connection = null;
        Channel channel = null;
        try {
            //建立连接
            connection = connectionFactory.newConnection();
            //创建会话通道,生产者和mq服务所有通信都在channel通道中完成
            channel = connection.createChannel();
            //声明队列,如果队列在mq中没有,则要创建
            //String queue, boolean durable, boolean exclusive, boolean autoDelete, Map arguments
            
            channel.queueDeclare(QUEUE,true,false,false,null);
            //发送消息
            //参数:String exchange, String routingKey, BasicProperties props, byte[] body
            
            //消息内容
            String message = "hello world 小伙子";
            channel.basicPublish("",QUEUE,null,message.getBytes());
            System.out.println("send to mq" + message);
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            //关闭连接,先关闭通道
            try {
                channel.close();
            } catch (IOException e) {
                e.printStackTrace();
            } catch (TimeoutException e) {
                e.printStackTrace();
            }
            try {
                connection.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

Consumer01——消费者

package com.rabbitmq;

import com.rabbitmq.client.*;

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

public class Consumer01 {
    //队列
    private static final String QUEUE = "helloword2";

    public static void main(String[] args) throws IOException, TimeoutException {
        //通过连接工厂创建新的连接和mq建立连接
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("127.0.0.1");
        connectionFactory.setPort(5672);//端口
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");
        //设置虚拟机,一个mq服务可以设置多个虚拟机,每个虚拟机就相当于一个独立的mq
        connectionFactory.setVirtualHost("/");
        Connection connection = null;
        //建立连接
        connection = connectionFactory.newConnection();
        //创建会话通道,生产者和mq服务所有通信都在channel通道中完成
        Channel channel = connection.createChannel();
        channel.queueDeclare(QUEUE,true,false,false,null);
        //实现消费方法
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
            
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //交换机
                String exchange = envelope.getExchange();
                //消息id,mq在channel中永安里标识消息的id,可用于确认消息已接收
                long deliveryTag = envelope.getDeliveryTag();
                //消息内容
                String message = new String(body, "utf-8");
                System.out.println("receive message" + message);
            }
        };

        //监听队列
        //参数:String queue, boolean autoAck, Consumer callback
        
        channel.basicConsume(QUEUE,true,defaultConsumer);
    }
}

2.3 总结

一、发送端执行流程

  1. 创建连接
  2. 创建通道
  3. 声明队列
  4. 发送消息

二、接收端

  1. 创建连接
  2. 创建通道
  3. 创建队列
  4. 监听队列
  5. 接收消息
  6. ack回复
3、工作模式

RabbitMQ 有一下几种工作模式:

  1. Work queues 工作队列
  2. pubish/Subscribe 发布订阅
  3. Routing 路由
  4. Topics 通配符
  5. Header Header转发器
  6. RPC 远程过程调用
3.1 Work queues 工作模式:

work queues与入门程序相比,多了一个消费者,两个消费者痛一个队列中的消息,它的特点如下:

一个生产者将消息发给一个队列

多个消费者共同监听一个队列的消息

消息不能被重复消费

rabbit采用轮询的方式将消息是平均的发给消费者

测试

运行多个消费者,运行一个生产者会给一个消费者发送消息,再次运行会给另一个发消息,不会重复给一个消费者发送。

3.2 Publish/subscribe 工作模式:

发布订阅模式:

1、一个生产者将消息发送给交换机

2、与交换机绑定的有多个队列,每个消费者监听自己的队列。

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

4、如果消息发给没有绑定队列的交换机上消息将丢失。

publish/subscribe与work queues有什么区别?

1、publish/subcribe可以定义一个交换机绑定多个队列,一个消息可以发送个多个队列。

2、work queues无需定义交换机,一个消息一次只能发送给一个队列。

3、publish/subscribe比work queues的功能更强大,publish/subcribe也可以将多个消费者监听同一个队列实现work queues的功能。

代码 消费者——Producer02_publish
package com.rabbitmq;

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 Producer02_publish {
    //队列名称
    private static final String QUEUE_INFORM_EMAIL = "queue_inform_email";
    private static final String QUEUE_INFORM_SMS = "queue_inform_sms";
    private static final String EXCHANGE_FANOUT_INFORM = "exchange_fanout_inform";


    public static void main(String[] args) {
        //通过连接工厂创建新的连接和mq建立连接
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("127.0.0.1");
        connectionFactory.setPort(5672);//端口
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");
        //设置虚拟机,一个mq服务可以设置多个虚拟机,每个虚拟机就相当于一个独立的mq
        connectionFactory.setVirtualHost("/");
        Connection connection = null;
        Channel channel = null;
        try {
            //建立连接
            connection = connectionFactory.newConnection();
            //创建会话通道,生产者和mq服务所有通信都在channel通道中完成
            channel = connection.createChannel();
            //声明队列,如果队列在mq中没有,则要创建
            //String queue, boolean durable, boolean exclusive, boolean autoDelete, Map arguments

            channel.queueDeclare(QUEUE_INFORM_EMAIL,true,false,false,null);
            channel.queueDeclare(QUEUE_INFORM_SMS,true,false,false,null);
            //声明一个交换机
            //参数:String exchange,String type
            
            channel.exchangeDeclare(EXCHANGE_FANOUT_INFORM, BuiltinExchangeType.FANOUT);
            //进行交换机和队列绑定
            //参数:String queue.String exchange, String routingkey
            
            channel.queueBind(QUEUE_INFORM_EMAIL,EXCHANGE_FANOUT_INFORM,"");
            channel.queueBind(QUEUE_INFORM_SMS,EXCHANGE_FANOUT_INFORM,"");

            for (int i = 0; i < 5; i++) {
                //消息内容
                String message = "send inform message user" + i;
                channel.basicPublish(EXCHANGE_FANOUT_INFORM,"",null,message.getBytes());
                System.out.println("send to mq" + message);
            }

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            //关闭连接,先关闭通道
            try {
                channel.close();
            } catch (IOException e) {
                e.printStackTrace();
            } catch (TimeoutException e) {
                e.printStackTrace();
            }
            try {
                connection.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
生产者——Consumer02_subscribe_email
package com.rabbitmq;

import com.rabbitmq.client.*;

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

public class Consumer02_subscribe_email {
    //队列名称
    private static final String QUEUE_INFORM_EMAIL = "queue_inform_email";
    private static final String EXCHANGE_FANOUT_INFORM = "exchange_fanout_inform";

    public static void main(String[] args) throws IOException, TimeoutException {
        //通过连接工厂创建新的连接和mq建立连接
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("127.0.0.1");
        connectionFactory.setPort(5672);//端口
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");
        //设置虚拟机,一个mq服务可以设置多个虚拟机,每个虚拟机就相当于一个独立的mq
        connectionFactory.setVirtualHost("/");
        Connection connection = null;
        //建立连接
        connection = connectionFactory.newConnection();
        //创建会话通道,生产者和mq服务所有通信都在channel通道中完成
        Channel channel = connection.createChannel();

        //声明队列
        channel.queueDeclare(QUEUE_INFORM_EMAIL,true,false,false,null);
        //声明一个交换机
        channel.exchangeDeclare(EXCHANGE_FANOUT_INFORM, BuiltinExchangeType.FANOUT);
        //进行交换机和队列绑定
        channel.queueBind(QUEUE_INFORM_EMAIL,EXCHANGE_FANOUT_INFORM,"");

        //实现消费方法
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
            
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //交换机
                String exchange = envelope.getExchange();
                //消息id,mq在channel中永安里标识消息的id,可用于确认消息已接收
                long deliveryTag = envelope.getDeliveryTag();
                //消息内容
                String message = new String(body, "utf-8");
                System.out.println("receive message" + message);
            }
        };

        //监听队列
        //参数:String queue, boolean autoAck, Consumer callback
        
        channel.basicConsume(QUEUE_INFORM_EMAIL,true,defaultConsumer);
    }
}
生产者——Consumer02_subscribe_sms
package com.rabbitmq;

import com.rabbitmq.client.*;

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

public class Consumer02_subscribe_sms {
    //队列名称
    private static final String QUEUE_INFORM_SMS = "queue_inform_sms";
    private static final String EXCHANGE_FANOUT_INFORM = "exchange_fanout_inform";

    public static void main(String[] args) throws IOException, TimeoutException {
        //通过连接工厂创建新的连接和mq建立连接
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("127.0.0.1");
        connectionFactory.setPort(5672);//端口
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");
        //设置虚拟机,一个mq服务可以设置多个虚拟机,每个虚拟机就相当于一个独立的mq
        connectionFactory.setVirtualHost("/");
        Connection connection = null;
        //建立连接
        connection = connectionFactory.newConnection();
        //创建会话通道,生产者和mq服务所有通信都在channel通道中完成
        Channel channel = connection.createChannel();

        //声明队列
        channel.queueDeclare(QUEUE_INFORM_SMS,true,false,false,null);
        //声明一个交换机
        channel.exchangeDeclare(EXCHANGE_FANOUT_INFORM, BuiltinExchangeType.FANOUT);
        //进行交换机和队列绑定
        channel.queueBind(QUEUE_INFORM_SMS,EXCHANGE_FANOUT_INFORM,"");

        //实现消费方法
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
            
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //交换机
                String exchange = envelope.getExchange();
                //消息id,mq在channel中永安里标识消息的id,可用于确认消息已接收
                long deliveryTag = envelope.getDeliveryTag();
                //消息内容
                String message = new String(body, "utf-8");
                System.out.println("receive message" + message);
            }
        };

        //监听队列
        //参数:String queue, boolean autoAck, Consumer callback
        
        channel.basicConsume(QUEUE_INFORM_SMS,true,defaultConsumer);
    }
}
3.3 Routing 工作模式:

路由模式:

1、一个交换机绑定多个队列,每个队列设置routingkey,并且一个队列可以设置多个routingkey

2、每个消费者监听自己的队列

3、生产者将教习发给交换机,发送消息时需要指定routingKey的值,交换机来判断改routingKey的值和哪个队列的routingKey相等,如果相等则将消息转发给该队列。

Routing模式和Publish/subscibe的区别?

Publish/subscibe模式在绑定交换机时不需要指定routingkey,消息会发送到每个绑定交换机的队列

Routing模式要求队列在绑定交换机时需要指定routingkey(这就是队列routingkey),发送消息将消息发送到和routingkey的值相等的队列中。正如上图所示,每个队列可以指定多个routingkey,如果发送消息时指定routingkey为 “error‘ ,由于C1和C2的routingkey都是error,所有消息会给它俩都发送。

如果发送消息时指定routingkey为"info",则只有C2可以接收到消息。

所以,Routing模式更加强大,它可以实现Publish/subscibe的功能。

代码 生产者——Producer03_routing
package com.rabbitmq;

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 Producer03_routing {
    //队列名称
    private static final String QUEUE_INFORM_EMAIL = "queue_inform_email";
    private static final String QUEUE_INFORM_SMS = "queue_inform_sms";
    private static final String EXCHANGE_ROUTING_INFORM = "exchange_routing_inform";
    private static final String ROUTINGKEY_EMAIL = "inform_email";
    private static final String ROUTINGKEY_SMS = "inform_sms";


    public static void main(String[] args) {
        //通过连接工厂创建新的连接和mq建立连接
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("127.0.0.1");
        connectionFactory.setPort(5672);//端口
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");
        //设置虚拟机,一个mq服务可以设置多个虚拟机,每个虚拟机就相当于一个独立的mq
        connectionFactory.setVirtualHost("/");
        Connection connection = null;
        Channel channel = null;
        try {
            //建立连接
            connection = connectionFactory.newConnection();
            //创建会话通道,生产者和mq服务所有通信都在channel通道中完成
            channel = connection.createChannel();
            //声明队列,如果队列在mq中没有,则要创建
            //String queue, boolean durable, boolean exclusive, boolean autoDelete, Map arguments

            channel.queueDeclare(QUEUE_INFORM_EMAIL,true,false,false,null);
            channel.queueDeclare(QUEUE_INFORM_SMS,true,false,false,null);
            //声明一个交换机
            //参数:String exchange,String type
            
            channel.exchangeDeclare(EXCHANGE_ROUTING_INFORM, BuiltinExchangeType.DIRECT);
            //进行交换机和队列绑定
            //参数:String queue.String exchange, String routingkey
            
            channel.queueBind(QUEUE_INFORM_EMAIL,EXCHANGE_ROUTING_INFORM,ROUTINGKEY_EMAIL);
            channel.queueBind(QUEUE_INFORM_EMAIL,EXCHANGE_ROUTING_INFORM,"inform");
            channel.queueBind(QUEUE_INFORM_SMS,EXCHANGE_ROUTING_INFORM,ROUTINGKEY_SMS);
            channel.queueBind(QUEUE_INFORM_SMS,EXCHANGE_ROUTING_INFORM,"inform");

            
            for (int i = 0; i < 3; i++) {
                //发送消息的时候指定
                String message = "send inform message user" + i;
                channel.basicPublish(EXCHANGE_ROUTING_INFORM,"inform",null,message.getBytes());
                System.out.println("send to mq" + message);
            }

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            //关闭连接,先关闭通道
            try {
                channel.close();
            } catch (IOException e) {
                e.printStackTrace();
            } catch (TimeoutException e) {
                e.printStackTrace();
            }
            try {
                connection.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
消费者——Consumer03_routing_sms
package com.rabbitmq;

import com.rabbitmq.client.*;

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

public class Consumer03_routing_sms {
    //队列名称
    private static final String EXCHANGE_ROUTING_INFORM = "exchange_routing_inform";
    private static final String QUEUE_INFORM_SMS = "queue_inform_sms";
    private static final String ROUTINGKEY_SMS = "inform_sms";

    public static void main(String[] args) throws IOException, TimeoutException {
        //通过连接工厂创建新的连接和mq建立连接
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("127.0.0.1");
        connectionFactory.setPort(5672);//端口
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");
        //设置虚拟机,一个mq服务可以设置多个虚拟机,每个虚拟机就相当于一个独立的mq
        connectionFactory.setVirtualHost("/");
        Connection connection = null;
        //建立连接
        connection = connectionFactory.newConnection();
        //创建会话通道,生产者和mq服务所有通信都在channel通道中完成
        Channel channel = connection.createChannel();

        //声明队列
        channel.queueDeclare(QUEUE_INFORM_SMS,true,false,false,null);
        //声明一个交换机
        channel.exchangeDeclare(EXCHANGE_ROUTING_INFORM, BuiltinExchangeType.DIRECT);
        //进行交换机和队列绑定
        channel.queueBind(QUEUE_INFORM_SMS,EXCHANGE_ROUTING_INFORM,ROUTINGKEY_SMS);

        //实现消费方法
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
            
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //交换机
                String exchange = envelope.getExchange();
                //消息id,mq在channel中永安里标识消息的id,可用于确认消息已接收
                long deliveryTag = envelope.getDeliveryTag();
                //消息内容
                String message = new String(body, "utf-8");
                System.out.println("receive message" + message);
            }
        };

        //监听队列
        //参数:String queue, boolean autoAck, Consumer callback
        
        channel.basicConsume(QUEUE_INFORM_SMS,true,defaultConsumer);
    }
}
消费者——Consumer03_routing_email
package com.rabbitmq;

import com.rabbitmq.client.*;

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

public class Consumer03_routing_email {
    //队列名称
    private static final String QUEUE_INFORM_EMAIL = "queue_inform_email";
    private static final String EXCHANGE_ROUTING_INFORM = "exchange_routing_inform";
    private static final String ROUTINGKEY_EMAIL = "inform_email";

    public static void main(String[] args) throws IOException, TimeoutException {
        //通过连接工厂创建新的连接和mq建立连接
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("127.0.0.1");
        connectionFactory.setPort(5672);//端口
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");
        //设置虚拟机,一个mq服务可以设置多个虚拟机,每个虚拟机就相当于一个独立的mq
        connectionFactory.setVirtualHost("/");
        Connection connection = null;
        //建立连接
        connection = connectionFactory.newConnection();
        //创建会话通道,生产者和mq服务所有通信都在channel通道中完成
        Channel channel = connection.createChannel();

        //声明队列
        channel.queueDeclare(QUEUE_INFORM_EMAIL,true,false,false,null);
        //声明一个交换机
        channel.exchangeDeclare(EXCHANGE_ROUTING_INFORM, BuiltinExchangeType.DIRECT);
        //进行交换机和队列绑定
        channel.queueBind(QUEUE_INFORM_EMAIL,EXCHANGE_ROUTING_INFORM,ROUTINGKEY_EMAIL);

        //实现消费方法
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
            
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //交换机
                String exchange = envelope.getExchange();
                //消息id,mq在channel中永安里标识消息的id,可用于确认消息已接收
                long deliveryTag = envelope.getDeliveryTag();
                //消息内容
                String message = new String(body, "utf-8");
                System.out.println("receive message" + message);
            }
        };

        //监听队列
        //参数:String queue, boolean autoAck, Consumer callback
        
        channel.basicConsume(QUEUE_INFORM_EMAIL,true,defaultConsumer);
    }
}
3.4 Topics 工作模式:

路由模式:

1、一个交换可以绑定多个队列,每个队列可以设置一个或多个带统配符的routingkey。

2、生产者将消息发给交换机,交换机根据routingkey的值来匹配队列,匹配时采用统配符方式,匹配成功的 将消息转发到指定的队列。

Topocs与Routing的区别?

Topics和Routing的基本原理相同,即:生产者将消息给交换机根据routingkey将消息转发给与routingkey匹配的队列。

不同之处是:routingkey的匹配方式,Routing模式是相等匹配,topics模式是统配符匹配。

符号#:匹配一个或者多个词(每个词中间以.分隔,后面不论点多少都可以匹配),比如inform.#可以匹配inform.sms、inform.email、inform.email.sms
符号*:只能匹配一个词,比如inform.*可以匹配inform.sms、inform.email
代码 生产者——Producer04_topics
package com.rabbitmq;

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 Producer04_topics {
    //队列名称
    private static final String QUEUE_INFORM_EMAIL = "queue_inform_email";
    private static final String QUEUE_INFORM_SMS = "queue_inform_sms";
    private static final String EXCHANGE_TOPICS_INFORM = "exchange_topics_inform";
    private static final String ROUTINGKEY_EMAIL = "inform.#.email.#";
    private static final String ROUTINGKEY_SMS = "inform.#.sms.#";


    public static void main(String[] args) {
        //通过连接工厂创建新的连接和mq建立连接
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("127.0.0.1");
        connectionFactory.setPort(5672);//端口
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");
        //设置虚拟机,一个mq服务可以设置多个虚拟机,每个虚拟机就相当于一个独立的mq
        connectionFactory.setVirtualHost("/");
        Connection connection = null;
        Channel channel = null;
        try {
            //建立连接
            connection = connectionFactory.newConnection();
            //创建会话通道,生产者和mq服务所有通信都在channel通道中完成
            channel = connection.createChannel();
            //声明队列,如果队列在mq中没有,则要创建
            //String queue, boolean durable, boolean exclusive, boolean autoDelete, Map arguments

            channel.queueDeclare(QUEUE_INFORM_EMAIL,true,false,false,null);
            channel.queueDeclare(QUEUE_INFORM_SMS,true,false,false,null);
            //声明一个交换机
            //参数:String exchange,String type
            
            channel.exchangeDeclare(EXCHANGE_TOPICS_INFORM, BuiltinExchangeType.TOPIC);
            //进行交换机和队列绑定
            //参数:String queue.String exchange, String routingkey
            
            channel.queueBind(QUEUE_INFORM_EMAIL,EXCHANGE_TOPICS_INFORM,ROUTINGKEY_EMAIL);
            channel.queueBind(QUEUE_INFORM_SMS,EXCHANGE_TOPICS_INFORM,ROUTINGKEY_SMS);

            for (int i = 0; i < 5; i++) {
                //发送消息的时候指定
                String message = "send email inform message user" + i;
                channel.basicPublish(EXCHANGE_TOPICS_INFORM,"inform.email",null,message.getBytes());
                System.out.println("send to mq" + message);
            }
            for (int i = 0; i < 3; i++) {
                //发送消息的时候指定
                String message = "send sms and email inform message user" + i;
                channel.basicPublish(EXCHANGE_TOPICS_INFORM,"inform.sms",null,message.getBytes());
                System.out.println("send to mq" + message);
            }
            for (int i = 0; i < 3; i++) {
                //发送消息的时候指定
                String message = "send sms and email inform message user" + i;
                channel.basicPublish(EXCHANGE_TOPICS_INFORM,"inform.sms.email",null,message.getBytes());
                System.out.println("send to mq" + message);
            }

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            //关闭连接,先关闭通道
            try {
                channel.close();
            } catch (IOException e) {
                e.printStackTrace();
            } catch (TimeoutException e) {
                e.printStackTrace();
            }
            try {
                connection.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
消费者——Consumer04_topics_email
package com.rabbitmq;

import com.rabbitmq.client.*;

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

public class Consumer04_topics_email {
    //队列名称
    private static final String QUEUE_INFORM_EMAIL = "queue_inform_email";
    private static final String EXCHANGE_TOPICS_INFORM = "exchange_topics_inform";
    private static final String ROUTINGKEY_EMAIL = "inform.#.email.#";

    public static void main(String[] args) throws IOException, TimeoutException {
        //通过连接工厂创建新的连接和mq建立连接
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("127.0.0.1");
        connectionFactory.setPort(5672);//端口
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");
        //设置虚拟机,一个mq服务可以设置多个虚拟机,每个虚拟机就相当于一个独立的mq
        connectionFactory.setVirtualHost("/");
        Connection connection = null;
        //建立连接
        connection = connectionFactory.newConnection();
        //创建会话通道,生产者和mq服务所有通信都在channel通道中完成
        Channel channel = connection.createChannel();

        //声明队列
        channel.queueDeclare(QUEUE_INFORM_EMAIL,true,false,false,null);
        //声明一个交换机
        channel.exchangeDeclare(EXCHANGE_TOPICS_INFORM, BuiltinExchangeType.TOPIC);
        //进行交换机和队列绑定
        channel.queueBind(QUEUE_INFORM_EMAIL,EXCHANGE_TOPICS_INFORM,ROUTINGKEY_EMAIL);

        //实现消费方法
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
            
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //交换机
                String exchange = envelope.getExchange();
                //消息id,mq在channel中永安里标识消息的id,可用于确认消息已接收
                long deliveryTag = envelope.getDeliveryTag();
                //消息内容
                String message = new String(body, "utf-8");
                System.out.println("receive message" + message);
            }
        };

        //监听队列
        //参数:String queue, boolean autoAck, Consumer callback
        
        channel.basicConsume(QUEUE_INFORM_EMAIL,true,defaultConsumer);
    }
}
消费者——Consumer04_topics_sms
package com.rabbitmq;

import com.rabbitmq.client.*;

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

public class Consumer04_topics_sms {
    //队列名称
    private static final String QUEUE_INFORM_SMS = "queue_inform_sms";
    private static final String EXCHANGE_TOPICS_INFORM = "exchange_topics_inform";
    private static final String ROUTINGKEY_SMS = "inform.#.sms.#";

    public static void main(String[] args) throws IOException, TimeoutException {
        //通过连接工厂创建新的连接和mq建立连接
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("127.0.0.1");
        connectionFactory.setPort(5672);//端口
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");
        //设置虚拟机,一个mq服务可以设置多个虚拟机,每个虚拟机就相当于一个独立的mq
        connectionFactory.setVirtualHost("/");
        Connection connection = null;
        //建立连接
        connection = connectionFactory.newConnection();
        //创建会话通道,生产者和mq服务所有通信都在channel通道中完成
        Channel channel = connection.createChannel();

        //声明队列
        channel.queueDeclare(QUEUE_INFORM_SMS,true,false,false,null);
        //声明一个交换机
        channel.exchangeDeclare(EXCHANGE_TOPICS_INFORM, BuiltinExchangeType.TOPIC);
        //进行交换机和队列绑定
        channel.queueBind(QUEUE_INFORM_SMS,EXCHANGE_TOPICS_INFORM,ROUTINGKEY_SMS);

        //实现消费方法
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
            
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //交换机
                String exchange = envelope.getExchange();
                //消息id,mq在channel中永安里标识消息的id,可用于确认消息已接收
                long deliveryTag = envelope.getDeliveryTag();
                //消息内容
                String message = new String(body, "utf-8");
                System.out.println("receive message" + message);
            }
        };

        //监听队列
        //参数:String queue, boolean autoAck, Consumer callback
        
        channel.basicConsume(QUEUE_INFORM_SMS,true,defaultConsumer);
    }
}
3.5 Header 模式

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

案例:

根据用户的通知设置去通知用户,设置接收Email的用户只接收Email,设置sms的用户只接收sms,设置两种通知类型都接收的则两种通知都有效。

3.6 RPC

RPC即客户端远程调用服务端的方法,使用MQ可以实现RPC的异步调用,基于Direct交换机实现,流程如下:

1、客户端即是生产者就是消费者,向RPC调用消息,同时监听RPC响应队列。

2、服务端监听RPC请求队列的消息,收到消息后执行服务端的方法,得到方法返回的结果

3、服务端将RPC 方法的结果发送到RPC响应队列

4、Spring整合RabbitMQ 4.1 环境搭建

依赖:


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


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


    org.springframework.boot
    spring-boot-starter-logging

配置:

server:
  port: 44000
spring:
  application:
    name: test-tabbitmq-producer
  rabbitmq:
    host: 127.0.0.1
    port: 5672
    username: guest
    password: guest
    virtual-host: /

日志:



    
    
        
            %d %-5level [%thread] %logger{0}: %msg%n
        
    

    
        
            %n ]]>
        
        192.168.1.100:5672
        admin
        admin
        /
        
        36
        false
        dataquality
        logstash
        true
        UTF-8
        true
        NON_PERSISTENT
        true
        rabbit.logs
        queue
    

    
    
    
    
    

    
        true
    

    
    
    
    
    

    
        
        
    

注意:此注解@RunWith用不了导入以下两个依赖



    junit
    junit
    4.12
    test



    org.junit.jupiter
    junit-jupiter-api
    5.6.3
    test

代码 RabbitmqConfig
package rabbitmq.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;

import java.util.concurrent.Exchanger;

@Configuration
public class RabbitmqConfig {

    private static final String QUEUE_INFORM_EMAIL = "queue_inform_email";
    private static final String QUEUE_INFORM_SMS = "queue_inform_sms";
    public static final String EXCHANGE_TOPICS_INFORM = "exchange_topics_inform";
    private static final String ROUTINGKEY_EMAIL = "inform.#.email.#";
    private static final String ROUTINGKEY_SMS = "inform.#.sms.#";

    //声明交换机
    @Bean(EXCHANGE_TOPICS_INFORM)
    public Exchanger EXCHANGER_TOPICS_INFORM(){
        //durable(true)持久化,mq重启之后交换机还在
        return ExchangeBuilder.topicExchange(EXCHANGE_TOPICS_INFORM).durable(true).build();
    }

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

    // ROUTINGKEY_EMAIL 绑定交换机和队列,指定routingkey
    @Bean
    public Binding BINDING_QUEUE_INFORM_EMAIL(@Qualifier(QUEUE_INFORM_EMAIL)Queue queue,
                                              @Qualifier(EXCHANGE_TOPICS_INFORM)Exchanger exchanger){
        return BindingBuilder.bind((Exchange) queue).to((Exchange) exchanger).with(ROUTINGKEY_EMAIL).noargs();
    }

    // ROUTINGKEY_SMS 绑定交换机和队列,指定routingkey
    @Bean
    public Binding BINDING_ROUTINGKEY_SMS(@Qualifier(QUEUE_INFORM_SMS)Queue queue,
                                              @Qualifier(EXCHANGE_TOPICS_INFORM)Exchanger exchanger){
        return BindingBuilder.bind((Exchange) queue).to((Exchange) exchanger).with(ROUTINGKEY_SMS).noargs();
    }
}
Producer05_topics_springboot
package com.rabbitmq;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import rabbitmq.config.RabbitmqConfig;

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

    @Autowired(required = false)
    RabbitTemplate rabbitTemplate;

    // 使用rabbitTemplate
    @Test
    public void testSenEmail(){
        String message = "send email message to user";
        
        rabbitTemplate.convertAndSend(RabbitmqConfig.EXCHANGE_TOPICS_INFORM,"inform.email",message);
    }
}
ReceiveHandler
@Component
public class ReceiveHandler {

    @RabbitListener(queues = "#{rabbitmqConfig.QUEUE_INFORM_EMAIL}")
    public void send_email(String msg, Message message, Channel channel){
        System.out.println("receive message is:"+msg);
    }
}
转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/948937.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号