RabbitMQ

最新推荐文章于 2024-05-30 23:16:51 发布

qq_29161317

最新推荐文章于 2024-05-30 23:16:51 发布

阅读量268

点赞数

1介绍

1.1RabbitMQ

MQ全程为Message Queue，即消息队列，RabbitMQ是由erlang语言开发，基于AMQP（Advanced Message Queuing Protocol高级消息队列协议）协议实现的消息队列，它是一种应用程序之间的通信方法，消息队列在分布式开发中应用非常广泛，RabbitMQ官方地址：http://www.rabbitmq.com/

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

1,、任务异步处理。

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

2、应用程序解耦合

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

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

ActiveMQ，RabbitMQ，ZeroMQ，Kafka，MetaMQ，RocketMQ，Redis。

为什么使用RabbitMQ呢？

1、使用简单，功能强大

2、基于AMQP协议。

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

4、高并发性能好，这主要得益于Erlang语言

5，Springboot默认集成RabbitMQ

1.2其他相关知识

AMQP是什么？

AMQP

AMQP，即Advanced Message Queuing Protocol，一个提供统一消息服务的应用层标准高级消息队列协议，是应用程序协议的一个开发标准，为面向消息的中间件设计。基于此协议的客户端与消息中间件可传递消息，并不受客户端/中间件不同产品，不同开发语言等条件的限制.Erlang中的实现有RabbitMQ等。

总结：AMQP是一套公开的消息队列协议，最早在2003年被提出，它旨在从协议层定义消息通信数据的标准格式，为的就是解决MQ市场上协议不统一的问题。RabbitMQ就是遵循AMQP标准协议开发的MQ服务。

官方：http://www.amqp.org/

JMS是什么？

JAVA消息服务

java消息服务（Java Message Service，JMS）应用程序接口是一个Java平台中关羽面向消息中间件（MOM）的API,用于在两个应用程序之间，或分布式系统中发送消息，进行异步通信。Java消息服务是一个与具体平台无关的API,绝大多数的MOM提供商都对JMS提供支持

总结：

JMS是Java提供的一套消息服务API标准，其目的是为所有的java应用程序提供统一的消息通信的标准，类似于java的jdbc，只要遵循jms标准的应用程序之间都可以进行消息通信，它和AMQP有什么不同，jms是java语言专属的消息服务标准，它是在api层定义标准，并且只能同于java应用；而AMQP是在协议层定义的标准，是跨语言的。

2快速入门

2.1RabbitMQ的工作原理

下图是RabbitMQ的基本结构：

组成部分说明如下：

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下载安装

2.2.1下载安装

RabbitMQ由Erlang语言开发，Erlang语言用于并发及分布式系统的开发，在电信领域应用广泛，OTP（Open Telecom Platform）作为Erlang语言的一部分，包含了很多基于Erlang的开发的中间件及工具库，安装RabbitMQ需要安装Erlang/OTP，并保持版本匹配，如下图：

RabbitMQ的下载地址：http://www.rabbitmq.com/download.html。

本次博文使用Erlang/OTP20.3版本和RabbitMQ3.7.3版本

1）下载erlang

地址如下：

http://erlang.org/download/otp_win64_20.3.exe

erlang安装完需要配置erlang环境变量:ERLANG_HOME=“erlang安装路径”，在path中添加%ERLANG_HOME%\bin;

2）安装RabbitMQ，下载完以管理员方式运行该文件进行安装。

地址如下：

https://github.com/rabbitmq/rabbitmq-server/releases/tag/v3.7.3

2.2.2启动

安装成功后会自动创建RabbitMQ服务并且启动

1）从开始菜单启动RabbitMQ

完成在开始菜单找到RabbitMQ的菜单

RabbitMQ Service-install：安装服务

RabbitMQ Service-remove：删除服务

RabbitMQ Service-start 启动

RabbitMQ Service-stop 关闭

2）如果没有开始菜单则进入安装目录下sbin目录手动启动：

1，安装并运行服务

2，安装管理插件

安装rabbitMQ的管理插件，方便在浏览器管理RabbitMQ

在sbin目录下，以管理员身份运行cmd，输入 rabbitmq-plugins.bat enable rabbitmq_management

3，启动成功登录RabbitMQ

进入浏览器，输入：http://localhost:15672

初始账号密码都为 guest

2.2.3注意事项

1，安装ERLANG和rabbitMQ以管理员身份进行

2，当卸载重新安装时会出现RabbitMQ服务注册失败，此时需要进入注册表清理erlang

搜索RabbitMQ，ErlSrv，将对应的项全部删除。

2.3Hello World

按照官方教程（http://www.rabbitmq.com/getstarted.html）测试hello world：

2.3.1搭建环境

1)java client

生产者和消费者都属于客户端，我们先用rabbitMQ官方提供的java client测试，目的是对rabbitMQ的交互过程有个清晰的认识

参考：https://github.com.rabbitmq/rabbitmq-java-client/

2）创建maven工程

创建生产者和消费者工程，分别加入RabbitMQ java client的依赖

test-rabbitmq-producer：生产者工程

test-rabbitmq-consumer：消费者工程

<dependency>
<groupId>com.rabbitmq</groupId>
<artifactId>amqp‐client</artifactId>
<version>4.0.3</version><!‐‐此版本与spring boot 1.5.9版本匹配‐‐>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring‐boot‐starter‐logging</artifactId>
</dependency>

2.3.2生产者

在生产者工程下的test中创建测试类如下

public class Producer01{

    //队列名称
    private static final String QUEUE = "helloworld";
    
    public static void main(String[] args) throws IOException,TimeoutException{
        Connection connection = null;
        Channel channel = null;
        try{
            ConnectionFactory factory = new ConnectionFactory();
            factory.setHost("localhost");
            factory.setPort(5672);
            factory.setUsername("guest");
            factory.setPassword("guest"); 
            //rabbitmq默认虚拟机名称为"/",虚拟机相当于一个独立的mq服务器
            factory.setVirtualHost("/");
            //创建于RabbitMQ服务器的TCP连接
            connection = factory.newConnection();
            //创建于Exchange的通道,每个连接可以创建多个通道,每个通道代表一个会话任务
            channel = connection.createChannel();
            /**
             * 声明队列,如果Rabbit中没有此队列将自动创建
             * param1：队列名称
             * param2：是否持久化
             * param3：队列是否独占连接
             * param4：队列不再使用时食肉自动删除此队列
             * param5：队列参数
             */
            channel.queueDeclare(QUEUE,true,false,false,null);
            String message = "hello world" + System.currentTimeMillis();
            
            /**
             * 消息发布方法
             * param1：Exchange的名称，如果没有指定，则使用DefaultExchange
             * param2：routingKey，消息的路由key，是用于Exchange（交换机）将消息转发到指定的              消息队列
             * param3：消息包含的属性
             * param4：消息体
             */
            /**
             * 这里没有指定交换机，消息将发送给默认交换机，每个队列也会绑定那个默认的交换机，但是不能显示绑定或者解除绑定
             * 默认的交换机，routingKey等于队列名称
             */
            channel.basicPublis("",QUEUE,null,message.getBytes("utf-8"));
            System.out.println("Send Message is:'" + message + "'");

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

2.3.3消费者

在消费者工程下的test中创建测试类如下

public class Consumer01{

    private static final String QUEUE = "hellowolrd";
    
    public static void main(Stringp[] args) throws IOException,TimeoutException{
        Connection connection = null;
        Chnanel channel = null;
        try{
            ConnectionFactory factory = new ConnectionFactory();
            //设置RabbitMQ所在服务器的ip和端口
            factory.setHost("localhost");
            factory.setPort(5672);
            factory.setUsername("guest");
            factory.setPassword("guest");

            connection = factory.newConnection();
            channel = connection.createChannel();
            //声明队列
            channel.queueDeclare(QUEUE,true,false,false,null);
            //定义消费方法
            DefaultConsumer consumer = new DefaultConsumer(channel){
                /**
                 * 消费者接收消息调用此方法
                 * param consumerTag 消费者的标签,在channel.basicConsume()去指定
                 * param envelope 消息包的内容,可从中获取消息id,消息routingkey,交换机,消息和重传标志(收到消息失败后是否需要重新发送)
                 * param properties 
                 * param body
                 */
                @Override
                public void handleDelivery(String consumerTag,
                                           Envelope envelope,
                                           AMQP.BasicProperties properties,
                                           byte[] body) throws IOException{
                    //交换机
                    String exchange = envelope.getExchange();
                    //路由key
                    String routingKey = envelope.getRoutingKey();
                    //消息id
                    String deliveryTag = envelope.getDeliveryTag();
                    //消息内容
                    String message = new String(body,"utf-8");
                    System.out.println("receive message" + message);

                }
            };

            /**
             * 监听队列String queue boolean autoAck,Consumer callback
             * 参数明细
             * 1,队列名称
             * 2,是否自动回复,设置为true为表示消息接收到自动向m回复收到了,mq接收回复后会删除消息,设置为false则需要手动回复
             * 3,消费消息的方法,消费者接收到消息后调用此方法
             */
            channel.basicConsume(QUEUE,true,consumer);

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

}

3工作模式

RabbitMQ有以下几种工作模式

1、Work queues

2、Publish/Subcribe

3、Routing

4、Topics

5、Header

6、RPC

3.1Work queues

work queues与入门程序相比，多了一个消费端，两个消费端共同消费同一个队列中的消息。

应用场景：对于任务过重或者任务较多情况使用工作队列可以提高任务处理的速度。

测试：

1、使用入门程序，启动多个消费者

2,、生产者发送多个消息

结果：

1、一条消息只会被一个消费者接收。

2、rabbit采用轮询的方式将消息平均地发送给消费者。

3、消费者在处理完某条消息后，才会收到下一条消息。

3.2Publish/Subscribe

3.2.1发布/订阅工作模式

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

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

3.2.2代码

案例：用户通知，当用户充值成功或者转账完成系统通知用户，通知方式有短信、邮件多种方法。

1、生产者

声明Exchange_fanout_inform交换机。

声明两个队列并且绑定到此交换机，绑定时不需要指定routingKey

发送消息时不需要指定routingKey

import com.rabbitmq.client.*;
import java.ioIOException;
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){
        Connection connection = null;
        Channel channel = null;
        try{
            //创建一个与MQ的连接
            ConnectionFactory factory = new ConnectionFactory();
            factory.setHost("127.0.0.1");
            factory.setPort(5672);
            factory.setUsername("guest");
            factory.setPassword("guest");
            factory.setVirtualHost("/");
            
            connection = factory.newConnection();
            channel = connection.createChannel();
            //声明交换机 String exchange,BuiltinExchangeType type
            /**
             * 参数明细
             * param1：交换机名称
             * param2：交换机类型 fanout、direct、topic、headers
             */
             channel.exchangeDeclare(EXCHANGE_FANOUT_INFORM,BuiltingExchangeType.FANOUT);
           
            //声明队列
            channel.queueDeclare(QUEUE_INFORM_EMAIL,true,false,false,null);
            channel.queueDeclare(QUEUE_INFORM_SMS,true,false,false,null);
            //交换机和队列绑定 String queue，String exchange，String routingKey
            /**
             * param1：队列名称
             * param2：交换机名称
             * param3：路由Key
             */
            channel.queueBind(QUEUE_INFORM_EMAIL, EXCHANGE_FANOUT_INFORM, "");
            channel.queueBind(QUEUE_INFOMR_SMS, EXCHANGE_FANOUT_INFORM, "");
            //发送消息
            for(int i=0 ;i<10; i++){
                String message = "inform to user"  + i;
                //向交换机发送消息String exchange,String routingKey,BasciProperties props,byte[] body
                /**
                 * 参数明细
                 * param1：交换机名称，不指定使用默认交换机名称 DefaultExchange
                 * param2：routingKey（路由Key），根据key名称将消息转发到具体的队列，这里填写队列名称表示消息将发送到此队列
                 * param3：消息属性
                 * param4：消息内容
                 */
                channel.basicPublish(EXCHANGE_FANOUT_INFORM,"",null,message.getBytes());
                System.out.println("Send Message is:'" + message + "'");   
            }
    
        }catch(IOException e){
            e.printStackTrace();    
        }finally{
            if(channel != null){
                try{
                    channel.close();   
                }catch(IOException e){
                    e.printStackTrace();
                }
            }

            if(conncetion != null){
                try{
                    conncetion.close();
                }catch(IOException e){
                    e.printStackTrace();
                }
                
            }
        }

    }


}

2、邮件发送消费者

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";

    private static void main(String[] args) throws IOException,TimeoutException{
    
        //创建一个与MQ的连接
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("127.0.0.1");
        factory.setPort(5672);
        factory.setUsername("guest");
        factory.setPassword("guest");
        factory.setVirturalHost("/");
        
        //创建一个连接
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();
        //声明交换机
        channel.exchangeDeclare(EXCHANGE_FANOUT_INFORM,BuiltingExchangeType.FANOUT);
        //声明队列
        channel.queueDeclare(QUEUE_INFORM_EMAIL,true,false,false,null);
        //交换机和队列绑定
        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{
                long deliveryTag = envelope.getDeliveryTag();
                String message = new String(body,"utf-8");
                System.out.println(message);
            }
        };

        //监听队列
        channel.basicConsume(QUEUE_INFORM_EMAIL,true,defaultConsumer);
        
    }
}

3，短信发送消费者

参考上面的邮件发送消费者代码编写

3.2.3测试

打开RabbitMQ的管理洁面，观察交换机的绑定情况。

结论：使用生产者发送若干条消息，每条消息都转发到各个队列，每个消费者都接收到了消息。

3.2.4思考

1、publish/subscribe与work queues有什么区别？

区别：

1）work queues不用定义交换机，而publish/subscribe需要定义交换机。

2）publish/subscribe的生产方少面向交换机发送消息，work queues的生产方少面向队列发送消息（底层使用默认交换机）

3）publish/subscribe需要设置队列和交换机的绑定，work queues不需要设置，实质上work queues会将队列绑定到默认的交换机。

相同点：

两者实现的发布/订阅的效果是一样的，多个消费端监听同一个队列不会重复消费信息。

2，实质工作用什么publish/subscribe还是work queues

建议使用publish/subscribe，发布订阅模式比工作队列模式更强大，并且发布订阅模式可以指定自己专用的交换机

3.3Routing

3.3.1路由模式：

1，每个消费者监听自己的队列，并且设置routingkey。

2，生产者将消息发送给交换机，由交换机根据routingkey来转发消息到指定的队列。

3.3.2代码

1、生产者

声明exchange_routing_inform交换机。

声明两个队列并且绑定到此交换机，绑定时需要指定routingkey

发送消息时需要指定routingkey

public class Producer03_routing{
 
    //队列名称
    private static final String QUEUE_INFORM_EMAIL = "queue_inform_email";
    private static final String QUEUE_INFORM_SMS = "queue_inform_email";
    private static final String EXCHANGE_ROUTING_INFORM = "exchange_routing_inform";
    
    public static void main(String[] args){
        Connection connection = null;
        Channel channel = null;
        try{
            ConnectionFactory factory = new ConnectionFactory();
            factory.setHost("127.0.0.1");
            factory.setPort(5672);
            factory.setUsername("guest");
            factory.setPassword("guest");
            factory.setVirtualHost("/");
            
            connection = factory.newConnection();
            channel = connection.createChannel();
            
            //声明交换机
            channel.exchangeDeclare(EXCHANGE_ROUTING_INFORM,BuiltinExchangeType.DIRECT);
            //声明队列
            channel.queueDeclare(QUEUE_INFORM_EMAIL,true,false,false,null);
            channel.queueDeclare(QUEUE_INFORM_SMS,true,false,false,null);

            //交换机和队列绑定
            channel.queueBind(QUEUE_INFORM_EMAIL,EXCHANGE_ROUTING_INFORM,QUEUE_INFORM_EMAIL);
channel.queueBind(QUEUE_INFORM_SMS,EXCHANGE_ROUTING_INFORM,QUEUE_INFORM_SMS);
            //发送邮件信息
            for(int i=0; i<10; i++){
                String message = "email inform to user" + i;
                //向交换机发送消息
                channel.basicPublish(EXCHANGE_ROUTING_INFORM,QUEUE_INFROM_EMAIL,null,message.getByte("utf-8"));
            System.out.println("Send Email is :'" + message + "'");
            
            }
             //发送手机信息
            for(int i=0; i<10; i++){
                String message = "sms inform to user" + i;
                //向交换机发送消息
                channel.basicPublish(EXCHANGE_ROUTING_INFORM,QUEUE_INFROM_SMS,null,message.getByte("utf-8"));
            System.out.println("Send Message is :'" + message + "'");
            
            }

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


    }
}

2、邮件发送消费者

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";

 
    public static void main(String[] args)throws IOException,TimeoutException{
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("127.0.0.1");
        factory.setPort(5672);
        factory.setUsername("guest");
        factory.setPassword("guest");
        factory.setVirtualHost("/");
        
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        channel.exchangeDeclare(EXCHANGE_ROUTING_INFORM, BuiltinExchangeType.DIRECT);
        //声明队列
        channel.queueDeclare(QUEUE_INFORM_EMAIL,true,false,false,null);
        //绑定队列和交换机
        channel.queueBind(QUEUE_INFORM_EMAIL,EXCHANGE_ROUTING_INFORM,QUEUE_INFORM_EMAIL);
        
        //定义消费方法
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
        
            @Override
            public void handleDeliverry(String consumerTag,Envelope envelope,
                        AMQP.BasicProperties,byte[] body) throws IOException{
                String message = new String(body,"utf-8");
            }
        };
        //监听队列
        channel.basicConsumer(QUEUE_INFORM_EMAIL,true, defaultConsumer);

    }   
}

3、短信发送消费者

参考邮件发送消费者的代码流程，编写短信通知的代码

3.3.3思考

1、Routing模式和publish/subscribe有啥区别？

Routing模式要求队列在绑定交换机时要指定routingkey，消息会转发到符合routingkey的队列

3.4Topics

3.4.1路由模式：

1、每个消费者监听自己的队列，并且设置带通配符的routingkey。

2、生产者将消息发给Broker，由交换机根据routingkey来转发消息到指定的队列。

3.4.2代码

1，生产者

声明交换机，指定topic类型

//声明交换机类型为topic
channel.exchangeDeclare(EXCHANGE_TOPICS_INFORM,BuiltinExchangeType.TOPIC);
//email通知
channel.basicPublish(EXCHANGE_TOPIC_INFORM,"inform.email",null, message.getBytes("utf-8"));
//sms通知
channel.basicPublish(EXCHANGE_TOPIC_INFORM,"inform.sms",null, message.getBytes("utf-8"));
//两种都通知
channel.basicPublish(EXCHANGE_TOPIC_INFORM,"inform.sms.email",message.getBytes("utf-8"));

2,消费者

队列绑定交换机指定通配符，通配符规则：

符号#可以匹配多个词，符号*可以匹配一个词语，中间以“.”分隔。例如inform.email被.分割成2个词语。

//声明队列
channel.queueDeclare(QUEUE_INFORM_EMAIL,true,false,false,null);
channel.queueDeclare(QUEUE_INFORM_SMS,true,false,false,null);

//声明交换机
channel.exchangeDeclare(EXCHANGE_TOPIC_INFORM,BuiltinExchangeType.TOPIC);
//绑定email通知队列
channel.queueBind(QUEUE_INFORM_EMAIL,EXCHANGE_TOPIC_INFORM,"inform.#.email.#");
//绑定sms通知队列
channel.queueBind(QUEUE_INFORM_SMS,EXCHANGE_TOPIC_INFORM,"inform.#.sms.#");

3.4.4思考

1、本案例的需求使用routing工作模式能否实现？

使用routing模式也可以实现本案例，共设置三个routingkey，分别是email、sms、all，email队列绑定email和all，sms队列绑定sms和all，这样就可以实现上边案例的功能，实现过程比topics复杂。

3.5Header模式

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

案例：

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

1，生产者

队列与交换机绑定的代码与之前不同，如下

Map<String,Object> headers_email = new HashTable<String,Object>();
headers_email.put("inform_type","email");
Map<String,Object> headers_sms = new HashTable<String,Object>();
headers_email.put("inform_type","sms");
channel.queueBind(QUEUE_INFORM_EMAIL,EXCHANGE_HEADERS_INFORM,"",headers_email);
channel.queueBind(QUEUE_INFORM_EMAIL,EXCHANGE_HEADERS_INFORM,"",headers_sms);

通知

String message = "email inform to user";
Map<String,Object> headers = new HashTable<String,Object>();
headers.put("inform_type","email");
AMQP.BasicProperties.Builder properties = new AMQP.BasciProperties.Builder();
properties.headers(headers);
channel.basicPublish(EXCHANGE_HEADERS_INFORM,"",properties.build(),message.getBytes("utf-8"));

2，消费者

channel.exchangeDeclare(EXCHANGE_HEADERS_INFORM,BuiltinExchangeType.HEADERS);
Map<String,Object> headers_email = new HashTable<String,Object>();
headers_email.put("inform_type","email");
channel.queueBind(QUEUE_INFORM_EMAIL,EXCHANGE_HEADERS_INFORM,"",header_email);
channel.basicConsumer(QUEUE_INFOMR_EMAIL,true,consumer);

3.6RPC

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

1、客户端即是生产者又是消费者，向rpc请求队列发送rpc调用消息，同时监听rpc响应队列。

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

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

4、客户端（rpc调用方）监听rpc响应队列，接收rpc调用结果

4 Spring整合RabbitMQ

4.1搭建SpringBoot环境

我们选择基于spring-rabbit去操作rabbitmq

使用spring-boot-strater-amqp会自动添加spring-rabbit依赖，如下：

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

4.2配置

1，配置application.yml

配置连接rabbitmq的参数

server:
    port: 44000
spring:
    application:
        name: test_rabbitmq-producer
    rabbitmq:
        host: 127.0.0.1
        port: 5672
        username: guest
        password: guest
        virtualHost: /

2，定义RabbitConfig类，配置Exchange,Queue,及绑定交换机

本例配置topic交换机

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

@Configuration
public class RabbitmqConfig{

    public static final String QUEUE_INFORM_EMAIL = "queue_inform_email";
    public static final String QUEUE_INFORM_SMS = "queue_inform_sms";
    
    public static final String EXCHANGE_TOPICS_INFORM = "exchange_topics_inform";

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

    //绑定队列到交换机
    @Bean
    public Binding BINDING_QUEUE_INFORM_SMS(@Qualifier(QUEUE_INFORM_SMS) Queue queue,
@Qualifier(EXCHANGE_TOPICS_INFORM) Exchange exchange){
        return BindingBuilder.bind(queue).to(exchange).with("inform.#.sms.#").noargs();

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

    }
}

4.3生产者

使用RabbitTemplate发送消息

import com.jiagui.rabbitmq.config.RabbitmqConfig;
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;

@SpringBootTest
@RunWith(SpringRunner.class)
public class Producer05_topics_springboot{
    @Autowired
    RabbitTemplate rabbitTemplate;
    
    @Test
    public void testsendByTopics(){
        for(int i=0; i<5; i++){
            String message = "sms email inform to user " + i;
            rabbitTemplate.converAndSend(RabbitmqConfig.EXCHANGE_TOPICS_INFORM,"inform.sms.email",message);
        }
    }

4.4消费者

消费者与生产者配置一样，只需要在监听方法上加上@RabbitListener注解即可

@Conponent
public class ReceiveHandler{
    //监听email队列
    @RabbitListener(queues = {RabbitnqConfig.QUEUE_INFORM_EMAIL})
    public void receive_email(String msg, Message message,Channel channel){
     
        System.out.println(msg);
    }
}

qq_29161317

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
RabbitMQ

1介绍1.1RabbitMQMQ全程为Message Queue，即消息队列，RabbitMQ是由erlang语言开发，基于AMQP（Advanced Message Queuing Protocol高级消息队列协议）协议实现的消息队列，它是一种应用程序之间的通信方法，消息队列在分布式开发中应用非常广泛，RabbitMQ官方地址：http://www.rabbitmq.com/开发中消...
复制链接

扫一扫