Springboot+rabbitmq的简单使用

Rabbitmq是什么

MQ全称为Message Queue, 消息队列（MQ）是一种应用程序对应用程序的通信方法。应用程序通过读写出入队列的消息（针对应用程序的数据）来通信，而无需专用连接来链接它们。
RabbitMQ是一个开源的AMQP实现，服务器端用Erlang语言编写，支持多种客户端，如：Python、Ruby、.NET、Java、JMS、C、PHP、ActionScript、XMPP、STOMP等，支持AJAX。用于在分布式系统中存储转发消息，在易用性、扩展性、高可用性等方面表现不俗。
AMQP，即Advanced Message Queuing Protocol，高级消息队列协议，是应用层协议的一个开放标准，为面向消息的中间件设计。AMQP的主要特征是面向消息、队列、路由（包括点对点和发布/订阅）、可靠性、安全。

Rabbitmq的简单图解

根据上述概念，我们可以了解到mq主要是在两个应用程序之间进行通信的中间件。而消息中间件可以用生产者-消费者模式来理解，如下图

rabbitmq在基本的消息中间件的基础上，加了一个exchange,如下图：

Exchange：消息交换机，它指定消息按什么规则，路由到哪个队列。
Queue：消息队列载体，每个消息都会被投入到一个或多个队列。
Binding：绑定，它的作用就是把exchange和queue按照路由规则绑定起来。
Routing Key：路由关键字，exchange根据这个关键字进行消息投递。

rabbitmq的使用过程

rabbitmq的使用过程大概如下：

1. 客户端连接到消息队列服务器，打开一个channel。
2. 客户端声明一个exchange，并设置相关属性,相关属性包括exchange的名字，exchange是否可以被持久化(持久化到磁盘)，exchange是否自动删除
3. 客户端声明一个queue，并设置相关属性，相关属性包括queue的名字，queue是否可以被持久化(持久化到磁盘)，queue是否自动删除
4. 声明exchange和queue之间的binding关系，用唯一的key来进行绑定
5. 客户端投递消息到exchange。
6. 不同类型的exchange根据路由规则将消息分发到不同的queue中
7. 客户端监听到queue中的内容，将消息取出消费，发送ack到rabbitmq中，删除该条消息

Springboot集成Rabbitmq实现即时消息发送

新建maven项目
在pom文件中加入

<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-amqpartifactId>
dependency>

在application.properties文件中配置

spring.rabbitmq.host=localhost
spring.rabbitmq.port=5672
spring.rabbitmq.username=admin
spring.rabbitmq.password=admin

初始化rabbitmq的exchange,queue以及他们之间的绑定关系(及上文过程中描述的#2 #3 #4)
RabbitmqConfig.java

package com.example.demo.Immediate;
import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.DirectExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RabbitmqConfig {

    // 创建一个立即消费队列
    @Bean
    public Queue immediateQueue() {
        // 第一个参数是创建的queue的名字，第二个参数是是否支持持久化
        return new Queue("immediate_queue_test1", true);
    }

    @Bean
    public DirectExchange immediateExchange() {
        // 一共有三种构造方法，可以只传exchange的名字， 第二种，可以传exchange名字，是否支持持久化，是否可以自动删除，
        //第三种在第二种参数上可以增加Map，Map中可以存放自定义exchange中的参数
        return new DirectExchange("immediate_exchange_test1", true, false);
    }

    @Bean
    //把立即消费的队列和立即消费的exchange绑定在一起
    public Binding immediateBinding() {
        return BindingBuilder.bind(immediateQueue()).to(immediateExchange()).with("immediate_routing_key_test1");
    }
}

生产者，则产生消息的客户端，将消息推到exchange中(即上文中描述的#5 #6)
Sender.java

package com.example.demo.Immediate;

import java.util.Date;

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class Sender {

    @Autowired
    RabbitTemplate rabbitTemplate;
    public void send() {
        String message =  "message" + new Date();
        System.out.println("Sender  " + message);
        rabbitTemplate.convertAndSend("immediate_exchange_test1", "immediate_routing_key_test1", message);
    }
}

消费者，则消费消息的客户端(即上文中描述的#7)
Receiver.java

package com.example.demo.Immediate;

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class Receiver {

    @RabbitHandler
    @RabbitListener(queues = "immediate_queue_test1")
    public void immediateProcess(String message) {
        System.out.println("Receiver" + message);
    }
}

Test.java

package com.example.demo;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import com.example.demo.Immediate.Sender;

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

    @Autowired
    Sender sender;

	@Test
	public void contextLoads() {
	    sender.send();
	}

}