RabbitMQ快速入门

RabbitMQ是一个开源的，实现AMQP协议的，可复用企业消息队列系统。

类似的系统还有ActiveMQ(实现JMS)和Kafka(分布式)。RabbitMQ支持主流的操作系统，支持多种开发语言，能降低系统间访问的耦合度，便于数据同步。

RabbitMQ提供如下5种队列模型(远程调用不是消息队列)。

1.Simple

2.Work. 工作模式，一个消息只能被一个消费者获取。

3.Publish/Subscribe. 订阅模式，消息被路由投递给多个队列，一个消息被多个消费者获取。ExchangeType为fanout。

4.Routing. 路由模式，一个消息被多个消费者获取。并且消息的目的queue可被生产者指定。ExchangeType为direct。

5.Topic. 通配符模式，一个消息被多个消费者获取。消息的目的queue可用BindingKey以通配符(#：一个或多个词，*：一个词)的方式指定。ExchangeType为topic。

6.

PRC. 远程调用

相关名词：

1. Server：RabbitMQ服务器，

2. VirtualHost：权限控制的基本单位，一个VirtualHost里面有若干Exchange和MessageQueue，以及指定被哪些user使用。

3. Connection：生产者/消费者和RabbitMQ服务器的TCP连接。

4. Channel：创建完Connection后，需创建信道才能执行AMQP命令。一个Connection可以创建多个Channel。

5. Exchange：路由。接受生产者发送的消息，并根据Binding规则将消息路由给服务器中的队列。ExchangeType有fanout、direct和topic三种，对应路由使用上述3/4/5号模型。

6. (Message)Queue：消息队列，用于存储还未被消费者消费的消息。

7. Message：由Header和Body组成。Header是生产者添加的相关属性：是否持久化、被哪个MessageQueue接收、优先级等。而Body是传输的数据。

8. Binding：消息被复制传递时，一个消费者对应一个消息队列，消费者绑定MessageQueue到Exchange，可指定多个Bindingkey。生产者在发送Message时，可以在header指定RoutingKey，Exchange匹配RoutingKey和Bindingkey将Message路由到相应的Queue。

9. Command：AMQP命令，生产者/消费者通过Command完成与RabbitMQ服务器交互。Publish：发送消息，txSelect：开启事务，txCommit：提交事务。

程序员应该用代码来表达自己的思想，下面用代码展示以上五种模式：

首先创建工厂类，获取Connection

public class ConnectionUtil {

    public static Connection getConnection() throws Exception {
        //connection工厂
        ConnectionFactory factory = new ConnectionFactory();
       
        factory.setHost("localhost");
        factory.setPort(5672);
        factory.setUsername("zx");
        factory.setPassword("zx");
        factory.setVirtualHost("/zx");
        
        // 通过工厂获取连接
        Connection connection = factory.newConnection();
        return connection;
    }
}

1.Simple

生产者

public class Send {

    private final static String QUEUE_NAME = "queue_simple";

    public static void main(String[] argv) throws Exception {
        // 获取连接
        Connection connection = ConnectionUtil.getConnection();
        // 创建通道
        Channel channel = connection.createChannel();

        // 声明队列 (不存在则创建)
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);

        // 发送消息
        String message = "Hello World";
        channel.basicPublish("", QUEUE_NAME, null, message.getBytes());

        // 关闭通道和连接
        channel.close();
        connection.close();
    }
}

消费者

public class Recv {

    private final static String QUEUE_NAME = "queue_simple";

    public static void main(String[] argv) throws Exception {

        // 获取连接
        Connection connection = ConnectionUtil.getConnection();
        // 创建通道
        Channel channel = connection.createChannel();

        // 声明队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);

        // 定义队列的消费者
        QueueingConsumer consumer = new QueueingConsumer(channel);
        // 监听队列
        channel.basicConsume(QUEUE_NAME, true, consumer);  //true 自动确认消息, 下有详解

        // 获取消息
        while (true) {
            QueueingConsumer.Delivery delivery = consumer.nextDelivery(); //阻塞或轮询
            String message = new String(delivery.getBody());
            System.out.println("获取:" + message);
        }
    }
}

2.Work

生产者

public class Send {

    private final static String QUEUE_NAME = "queue_work";

    public static void main(String[] argv) throws Exception {
        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();

        // 声明队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);

        for (int i = 0; i < 50; i++) {
            String message = "" + i;
            channel.basicPublish("", QUEUE_NAME, null, message.getBytes());

            Thread.sleep(i * 10);
        }

        channel.close();
        connection.close();
    }
}

消费者1

public class Recv1 {

    private final static String QUEUE_NAME = "queue_work";

    public static void main(String[] argv) throws Exception {

        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);

        // 开启Qos, 同一时刻服务器只发送一条消息. 可以尝试注释该行, 会发现消息会被平均分配给两个消费者
        channel.basicQos(1);

        QueueingConsumer consumer = new QueueingConsumer(channel);
        channel.basicConsume(QUEUE_NAME, false, consumer);
        while (true) {
            QueueingConsumer.Delivery delivery = consumer.nextDelivery();
            String message = new String(delivery.getBody());
            System.out.println("获取:" + message);
            // 模拟handling
            Thread.sleep(100);
            // 手动确认消息接收. 在basicConsume方法中, true为自动, false为手动
            /* 消息确认方式: 
             * 1. 自动确认. 只要消息从队列中移除, 服务端认为消息被成功消费
             * 2. 手动确认. 消费者获取消息后, 服务器将该消息标记为不可用, 并等待反馈. 如果消费者一直不反馈, 则该消息将一直处于不可用状态
             */
            channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
        }
    }
}

消费者2

public class Recv2 {

    private final static String QUEUE_NAME = "queue_work";

    public static void main(String[] argv) throws Exception {

        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();

        channel.queueDeclare(QUEUE_NAME, false, false, false, null);

        channel.basicQos(1);

        QueueingConsumer consumer = new QueueingConsumer(channel);
        channel.basicConsume(QUEUE_NAME, false, consumer);
        while (true) {
            QueueingConsumer.Delivery delivery = consumer.nextDelivery();
            String message = new String(delivery.getBody());
            System.out.println(" [x] Received '" + message + "'");
            // 模拟handling
            Thread.sleep(200);
            // ACK
            channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
        }
    }
}

3.Publish/Subscribe

生产者

public class Send {

    private final static String EXCHANGE_NAME = "exchange_fanout";

    public static void main(String[] argv) throws Exception {
        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();

        // 声明exchange
        channel.exchangeDeclare(EXCHANGE_NAME, "fanout");

        // 消息内容
        String message = "Hello world";
        // 与前面不同, 生产者将消息发送给exchange, 而非队列. 若发消息时还没消费者绑定queue与该exchange, 消息将丢失
        channel.basicPublish(EXCHANGE_NAME, "", null, message.getBytes());
        channel.close();
        connection.close();
    }
}

消费者1

public class Recv1 {

    private final static String QUEUE_NAME = "queue_fanout_1";
    private final static String EXCHANGE_NAME = "exchange_fanout";

    public static void main(String[] argv) throws Exception {

        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);

        // 绑定队列到交换机. 绑定也可在rabbitMQ的管理界面进行
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "");

        channel.basicQos(1);
        QueueingConsumer consumer = new QueueingConsumer(channel);
        channel.basicConsume(QUEUE_NAME, false, consumer);

        while (true) {
            QueueingConsumer.Delivery delivery = consumer.nextDelivery();
            String message = new String(delivery.getBody());
            System.out.println("获取:" + message);
            Thread.sleep(100);
            channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
        }
    }
}

消费者2

public class Recv2 {

    private final static String QUEUE_NAME = "queue_fanout_2";
    private final static String EXCHANGE_NAME = "exchange_fanout";

    public static void main(String[] argv) throws Exception {

        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);

        // 绑定队列到交换机
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "");

        channel.basicQos(1);
        QueueingConsumer consumer = new QueueingConsumer(channel);
        channel.basicConsume(QUEUE_NAME, false, consumer);

        while (true) {
            QueueingConsumer.Delivery delivery = consumer.nextDelivery();
            String message = new String(delivery.getBody());
            System.out.println("获取:" + message);
            Thread.sleep(200);
            channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
        }
    }
}

4.Routing

生产者

public class Send {

    private final static String EXCHANGE_NAME = "exchange_direct";

    public static void main(String[] argv) throws Exception {
        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();

        // 声明exchange
        channel.exchangeDeclare(EXCHANGE_NAME, "direct");

        String message = "Hello world";
        // 发送消息, RoutingKey为 insert
        channel.basicPublish(EXCHANGE_NAME, "insert", null, message.getBytes());

        channel.close();
        connection.close();
    }
}

消费者1

public class Recv1 {

    private final static String QUEUE_NAME = "queue_direct_1";
    private final static String EXCHANGE_NAME = "exchange_direct";

    public static void main(String[] argv) throws Exception {

        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        // 绑定队列到交换机, BindingKey为 delete update
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "update");
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "delete");

        channel.basicQos(1);
        QueueingConsumer consumer = new QueueingConsumer(channel);
        channel.basicConsume(QUEUE_NAME, false, consumer);

        while (true) {
            QueueingConsumer.Delivery delivery = consumer.nextDelivery();
            String message = new String(delivery.getBody());
            System.out.println("获取:" + message);
            Thread.sleep(100);
            channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
        }
    }
}

消费者2

public class Recv2 {

    private final static String QUEUE_NAME = "queue_direct_2";
    private final static String EXCHANGE_NAME = "exchange_direct";

    public static void main(String[] argv) throws Exception {

        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);

        // 绑定队列到交换机, BindingKey为 insert delete update
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "insert");
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "update");
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "delete");

        channel.basicQos(1);
        QueueingConsumer consumer = new QueueingConsumer(channel);
        channel.basicConsume(QUEUE_NAME, false, consumer);

        while (true) {
            QueueingConsumer.Delivery delivery = consumer.nextDelivery();
            String message = new String(delivery.getBody());
            System.out.println("获取:" + message);
            Thread.sleep(200);
            channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
        }
    }
}

5.Topic

生产者

public class Send {

    private final static String EXCHANGE_NAME = "exchange_topic";

    public static void main(String[] argv) throws Exception {
        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();

        // 声明exchange
        channel.exchangeDeclare(EXCHANGE_NAME, "topic");

        String message = "Hello world";
        // 发送消息, 指定RoutingKey
        channel.basicPublish(EXCHANGE_NAME, "item.delete", null, message.getBytes());

        channel.close();
        connection.close();
    }
}

消费者1

public class Recv1 {

    private final static String QUEUE_NAME = "queue_topic_1";
    private final static String EXCHANGE_NAME = "exchange_topic";

    public static void main(String[] argv) throws Exception {

        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);

        // 绑定队列到交换机
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "item.update");
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "item.delete");

        channel.basicQos(1);
        QueueingConsumer consumer = new QueueingConsumer(channel);
        channel.basicConsume(QUEUE_NAME, false, consumer);
        
        while (true) {
            QueueingConsumer.Delivery delivery = consumer.nextDelivery();
            String message = new String(delivery.getBody());
            System.out.println("获取:" + message);
            Thread.sleep(100);
            channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
        }
    }
}

消费者2

public class Recv2 {

    private final static String QUEUE_NAME = "queue_topic_2";

    private final static String EXCHANGE_NAME = "exchange_topic";

    public static void main(String[] argv) throws Exception {

        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);

        // 绑定队列到交换机. 通配符!
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "item.#");

        channel.basicQos(1);
        QueueingConsumer consumer = new QueueingConsumer(channel);
        channel.basicConsume(QUEUE_NAME, false, consumer);

        while (true) {
            QueueingConsumer.Delivery delivery = consumer.nextDelivery();
            String message = new String(delivery.getBody());
            System.out.println("获取:'" + message);
            Thread.sleep(200);
            channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
        }
    }
}

可以看出，上面调用的关系比较复杂。

幸运的是，Spring提供了对rabbitMQ的封装，将复杂的关系设置整合到配置文件中。

依赖于两个组件，抽象层spring-amqp和实现层spring-rabbit。

于是代码简化为:

生产者

public class Send {
    
    public static void main(String[] args) throws InterruptedException {
        AbstractApplicationContext ctx = new ClassPathXmlApplicationContext("classpath:spring/rabbitmq-context.xml");
        
        //拿模板的bean
        RabbitTemplate template = ctx.getBean(RabbitTemplate.class);
        //发消息
        String msg = "Hello world";
        template.convertAndSend(msg);   //该函数还能指定routing-key
        
        Thread.sleep(1000);
        ctx.close();
    }
}

消费者

public class Recv {
    public void listen(String msg) {
        System.out.println("获取" + msg);
    }
}

非常漂亮的封装。配置文件如下

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:rabbit="http://www.springframework.org/schema/rabbit"
    xsi:schemaLocation="http://www.springframework.org/schema/rabbit
    http://www.springframework.org/schema/rabbit/spring-rabbit-1.4.xsd
    http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-4.1.xsd">

    <!-- connection工厂 -->
    <rabbit:connection-factory id="connectionFactory"
        host="127.0.0.1" port="5672" username="zx" password="zx"
        virtual-host="/zx" />

    <!-- MQ的管理，包括队列、交换器等 -->
    <rabbit:admin connection-factory="connectionFactory" />

    <!-- 声明队列 (auto表示需要时创建)-->
    <rabbit:queue name="myQueue" auto-declare="true"/>
    
    <!-- 声明fanout类型的exchange (auto表示需要时创建) -->
    <rabbit:fanout-exchange name ="fanoutExchange" auto-declare="true" durable="true" >  <!-- durable是否持久化, 安全性还是性能的权衡 -->
        <!-- 注意, 在生产者/消费者 分离的系统中, exchange和queue也分离, 绑定应该交给运维在rabbit管理界面进行, 而不是配置下面的bindings属性 -->
        <!-- 小细节, rabbit管理界面绑定时界面属性中binding key被写成了routing key? -->
        <rabbit:bindings>
            <rabbit:binding queue="myQueue"/>  <!-- 还能指定通过pattern属性指定bindingType -->
        </rabbit:bindings>
    </rabbit:fanout-exchange>

    <!-- 定义Rabbit模板的bean，指定 exchange或queue -->
    <rabbit:template id="amqpTemplate" connection-factory="connectionFactory" exchange="fanoutExchange" />  <!-- 还能指定routing-key属性 -->

    <bean id="recv" class="com.zx.rabbitmq.spring.Recv" />
    <!-- 设置消费者要监听的队列, 并指定有消息时执行的方法 -->
    <rabbit:listener-container connection-factory="connectionFactory">
        <rabbit:listener ref="recv" method="listen" queue-names="myQueue" />
    </rabbit:listener-container>

</beans>