rabbitmq消息队列

1.Rabbitmq架构

• producer: 生产者，发布消息者，消息的源头，向exchange发布消息的应用程序
• consumer: 消费者，消费消息，消息的接受者，向queue获取到消息
• broker: 具体的服务器
• vhost: 虚拟主机，一个broker可以构建多个vhost，一个vhost包含exchanger,queue，bingding和权限机制。
• exchanger: 交换器，接收生产者发布的消息，并且依据bingding规则发送给具体的队列。
• binding: 绑定，队列与交换器之间的绑定关系。
• queue: 存放来自交换器的消息，消费者消息的来源。
• message: 消息，由消息头和消息体组成，消息体是透明的，消息头由一些可选属性组成，包括路由键（routing-key）,优先级（priority）和是否持久化存储等。
• routing-key:

2.Exchanger分发消息类型

exchanger分发消息一共有4种方式：headers,direct,fanout,topic;headers方式采用header匹配方式，同direct,性能很差，所以不被经常使用。

• fanout: 分发模式，一个消息发送到交换器上后，那么就会将消息发送到所有与该交换器相关的队列，不进行路由键的匹配。
• direct: 消息的路由键和队列的路由键完全匹配，就将消息发送到该队列
• topic: 不同于direct的完全匹配，topic方式依据制定的规则进行匹配。（topic路由键规则：*代表一个字符，#代表0个或多个字符）

demo: 参考

引入依赖
<dependency>
    <groupId>com.rabbitmq</groupId>
    <artifactId>amqp-client</artifactId>
    <version>4.1.0</version>
</dependency>

生产者：

package org.study.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 Producer {

    public static void main(String[] args) throws IOException, TimeoutException {
        //创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setUsername("guest");
        factory.setPassword("guest");
        //设置 RabbitMQ 地址
        factory.setHost("localhost");
        //建立到代理服务器到连接
        Connection conn = factory.newConnection();
        //获得信道
        Channel channel = conn.createChannel();
        //声明交换器
        String exchangeName = "hello-exchange";
        channel.exchangeDeclare(exchangeName, "direct", true);

        String routingKey = "hola";
        //发布消息
        byte[] messageBodyBytes = "quit".getBytes();
        channel.basicPublish(exchangeName, routingKey, null, messageBodyBytes);

        channel.close();
        conn.close();
    }
}

消费者

package org.study.rabbitmq;
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
public class Consumer {

    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setUsername("guest");
        factory.setPassword("guest");
        factory.setHost("localhost");
        //建立到代理服务器到连接
        Connection conn = factory.newConnection();
        //获得信道
        final Channel channel = conn.createChannel();
        //声明交换器
        String exchangeName = "hello-exchange";
        channel.exchangeDeclare(exchangeName, "direct", true);
        //声明队列
        String queueName = channel.queueDeclare().getQueue();
        String routingKey = "hola";
        //绑定队列，通过键 hola 将队列和交换器绑定起来
        channel.queueBind(queueName, exchangeName, routingKey);

        while(true) {
            //消费消息
            boolean autoAck = false;
            String consumerTag = "";
            channel.basicConsume(queueName, autoAck, consumerTag, new DefaultConsumer(channel) {
                @Override
                public void handleDelivery(String consumerTag,
                                           Envelope envelope,
                                           AMQP.BasicProperties properties,
                                           byte[] body) throws IOException {
                    String routingKey = envelope.getRoutingKey();
                    String contentType = properties.getContentType();
                    System.out.println("消费的路由键：" + routingKey);
                    System.out.println("消费的内容类型：" + contentType);
                    long deliveryTag = envelope.getDeliveryTag();
                    //确认消息
                    channel.basicAck(deliveryTag, false);
                    System.out.println("消费的消息体内容：");
                    String bodyStr = new String(body, "UTF-8");
                    System.out.println(bodyStr);

                }
            });
        }
    }
}