RabbitMQ入门笔记

最新推荐文章于 2024-07-16 16:37:56 发布

四叶猫

最新推荐文章于 2024-07-16 16:37:56 发布

阅读量438

点赞数

文章标签： rabbitmq 笔记分布式

本文链接：https://blog.csdn.net/qq_42994789/article/details/132536006

版权

一、写在前面

什么是消息队列？

顾名思义，消息队列就是一个能够存放消息的队列，通常有一个生产者生产消息，一个或多个消费者消费消息。

消息队列在分布式系统中运用十分广泛，有异步处理、应用解耦、流量削峰等用途。

当然，RabbitMQ不是消息队列的唯一选择，除它以外还有在大数据中十分常见的Kafka、阿里的RocketMQ、Apache的ActiveMQ，甚至Redis也可以当成消息队列使用。

不过，正常情况下RabbitMQ是比较通用的选择。

RabbitMQ基础模型

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DPuLCnGj-1693195054817)(http://www.siyemao.xyz/images/1640611813402.png)]

上面是rabbitmq的基础模型，可以看到Server包裹着虚拟主机，一般来说，虚拟主机和用户相对应，一个Rabbitmq可以有多个虚拟主机、多个用户，以对应不同的系统不同的功能模块。

此外，虚拟主机还包含着交换机和数个队列，生产者会将消息交给交换机，然后队列通过某种规则从交换机中取得消息，再由消费者拿到消息。当然，生产者是否要将消息交给交换机，取决于使用了哪种消息模型。

二、消息模型

1.HelloWorld（直连）模型。

一个生产者生产消息交给队列，消费者通过队列取得消息，非常简单的一对一消息模型。

首先编写一个获取RabbitMQ工厂对象的工具类：

package utils;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
public class RabbitMQUtil {
    private static ConnectionFactory connectionFactory;
    static {
        connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("www.siyemao.xyz");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/mao");
        connectionFactory.setUsername("siye");
        connectionFactory.setPassword("siye");
    }
    //定义提供连接对象的方法
    public static Connection getConnection() {
        try {
            return connectionFactory.newConnection();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
    //定义关闭通道和关闭连接工具的方法
    public static void closeConnectionAndChanel(Channel channel,Connection connection){
        try{
            if (channel != null) channel.close();
            if (connection != null) connection.close();
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

接着再创建生产者类和消费者类：

public class Provider {
    public static void main(String args[]) throws IOException, TimeoutException {
        Connection connection = RabbitMQUtil.getConnection();
        //通过连接获取通道
        Channel channel = connection.createChannel();
        //通道绑定对应消息队列
        //参数1：队列名称，如果队列不存在自动创建
        //参数2：队列是否持久化，true持久化队列，false不持久化
        //参数3：是否独占队列，true独占队列，false不独占
        //参数4：是否再消费完成后自动删除队列
        //参数5：额外附加参数
        channel.queueDeclare("hello",true,false,false,null);
        //发布消息
        //参数1：交换机名称，参数2：队列名称，参数3：传递消息额外设置(如果想要消息持久化，则使用MessageProperties.PERSISTENT_TEXT_PLAIN)，参数4：消息具体类容
        channel.basicPublish("","hello", MessageProperties.PERSISTENT_TEXT_PLAIN,"hello world".getBytes());
        RabbitMQUtil.closeConnectionAndChanel(channel,connection);
    }
}

public class Consumer {
    public static void main(String args[]) throws IOException, TimeoutException {
        //获取连接工厂
        Connection connection = RabbitMQUtil.getConnection();
        //创建通道
        Channel channel = connection.createChannel();
        //通道绑定对象
        channel.queueDeclare("hello",true,false,false,null);
        //消费消息
        //参数1：消费哪个队列 队列名称
        //参数2：开启消息的自动确认机制
        //参数3：消费时的回调接口
        channel.basicConsume("hello",true,new DefaultConsumer(channel){
            @Override//最后一个参数：消息队列中取出的消息
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("获取消息 " + new String(body));
            }
        });
    }
}

运行生产者类，然后再运行消费者类，就可以看到，消费者类拿到生产者的消息了~

2.work quene（工作队列）模型

一个消费者消费的速度还赶不上生产的速度，GDP上不来，那怎么办，创造多个消费者好了。

一样还是有一个生产者：

public class Provider {
    public static void main(String[] args) throws IOException {
        //获取连接
        Connection connection = RabbitMQUtil.getConnection();
        Channel channel = connection.createChannel();
        //通过通道声明队列
        channel.queueDeclare("work", true, false, false, null);
        //生产消息
        for (int i = 0; i < 10; i++) {
            channel.basicPublish("", "work", null, (i+"hello workqueue").getBytes());
        }
        //关闭资源
        RabbitMQUtil.closeConnectionAndChanel(channel, connection);
    }
}

不同的是有两个消费者：

public class Consumer1 {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMQUtil.getConnection();
        Channel channel = connection.createChannel();
        channel.basicQos(1);//一次只能消费一个消息
        channel.queueDeclare("work",true,false,false,null);
        //参数2：消费者自动向rabbitmq确认消息消费，这里设置为false，避免消费者死掉后消息随之消失
        channel.basicConsume("work",false,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者-1：" + new String(body));
                //手动确认消息消费完毕，参数1：确认标识 参数2：false每次确认一个
                channel.basicAck(envelope.getDeliveryTag(),false);
            }
        });
    }
}

public class Consumer2 {
    ……代码跟Consumer1一样
}

可以看到，和直连模型相比，工作模型并没有多出什么额外的东西，只是新增了一个消费者而已。

需要注意的是，为了避免消费者拿到消息后死掉，使消息也丢失，我们需要将通道设置为每次只能消费一个消息（channel.basicQos(1)），同时将消费消息时的第二个参数设置为false，取消自动确认，改为在消费完毕后手动确认。

另外。

默认情况下，消费者们采用轮询的方式获取消息，你一条我一条，哪怕其中一个消费者效率很慢也是这样。但按照上述设置后，就可以实现能者多劳的效果。

3.Fanout（广播）模型

在广播模型中，可以有多个消费者，每个消费者有自己的临时队列，生产者的消息交给交换机，交换机来决定交给哪个消费者的队列。一般情况下所有的消费者都能拿到消息，实现一条消息被多个消费者消费。

同样有一个生产者，但是生产者不声明队列，而是声明并指向交换机：

public class Provider {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMQUtil.getConnection();
        Channel channel = connection.createChannel();
        //将通道指向交换机 //参数1：交换机名称 参数2：交换机类型
        channel.exchangeDeclare("logs","fanout");
        //发送消息 参数1：交换机名称 参数2：路由key，在广播模型中可以忽略 参数3：消息体
        channel.basicPublish("logs","",null,"fanout type messgae".getBytes());
        RabbitMQUtil.closeConnectionAndChanel(channel,connection);
    }
}

消费者同样绑定交换机，并创建临时队列，临时队列绑定交换机：

public class Consumer1 {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMQUtil.getConnection();
        Channel channel = connection.createChannel();
        //通道绑定交换机
        channel.exchangeDeclare("logs","fanout");
        //创建临时队列
        String queueName = channel.queueDeclare().getQueue();
        //绑定交换机和队列
        channel.queueBind(queueName,"logs","");
        //消费消息
        channel.basicConsume(queueName,true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者-1：" + new String(body));
            }
        });
    }
}

消费者2、消费者3都是同样的代码，这里就省略掉了。

此时启动消费者，然后再启动生产者，就能看到所有消费者都拿到了同一条消息。

Routing（路由）模型

在广播模型中，所有消费者都能拿到消息，但是如果我们不想让他拿到呢？如果我们想要不同的消费去拿不同类型的消息呢？这个时候就能用到路由模型了。

4.路由之订阅模型-Direct（直连/订阅制）

在直连模型下，队列不能直接绑定交换机了，而是要指定一个routerkey，消息发送方在向交换机发送消息时也必须指定routerkey，这样交换机在把消息交给队列时，就会通过routerkey进行判断，实现”订阅制“。

和上面的所有模型一样，首先创建一个生产者：

public class Provider {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMQUtil.getConnection();
        Channel channel = connection.createChannel();
        //通过通道声明交换机，参数1：交换机名称 参数2：路由模式
        channel.exchangeDeclare("logs_direct","direct");
        //发送消息
        String routerKey = "info";
        channel.basicPublish("logs_direct",routerKey,null,("这是direct模型发布的基于RouterKey：[" + routerKey + "]发送的消息").getBytes());
        RabbitMQUtil.closeConnectionAndChanel(channel,connection);
    }
}

可以看到，这次指定了模式为direct路由模式，同时指定routerkey为info。

创建消费者1和消费者2：

public class Consumer1 {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMQUtil.getConnection();
        Channel channel = connection.createChannel();
        channel.exchangeDeclare("logs_direct","direct");
        //创建临时队列
        String queueName = channel.queueDeclare().getQueue();
        //基于routerkey绑定交换机
        channel.queueBind(queueName,"logs_direct","error");
        //消费消息
        channel.basicConsume(queueName,true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者1：" + new String(body));
            }
        });
    }
}

public class Consumer2 {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMQUtil.getConnection();
        Channel channel = connection.createChannel();
        channel.exchangeDeclare("logs_direct","direct");
        //创建临时队列
        String queueName = channel.queueDeclare().getQueue();
        //基于routerkey绑定交换机
        channel.queueBind(queueName,"logs_direct","info");
        channel.queueBind(queueName,"logs_direct","error");
        channel.queueBind(queueName,"logs_direct","warning");
        //消费消息
        channel.basicConsume(queueName,true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者2：" + new String(body));
            }
        });
    }
}

很明显的，消费者1只指定了一个routerkey：error，而消费者2则是有多个routerkey：info、error、warning……如果此时运行消费者1和2，然后运行生产者，消费者1空手而归，而消费者2就会拿到消息。这是因为2绑定了和生产者一样的routerkey：info。

5.Routing路由模型之Topics（动态路由）模型

在direct订阅模型中，如果需要接受多种消息，就要指定多个routerkey，如果数量一多就很很麻烦，这种情况就能使用topics模型。

public class Provider {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMQUtil.getConnection();
        Channel channel = connection.createChannel();
        //声明交换机和交换机类型
        channel.exchangeDeclare("topics","topic");
        //发布消息
        String routerKey = "user.save.info";
        channel.basicPublish("topics",routerKey,null,("这里是topic动态路由模型，routerkey：[" + routerKey + "]发布的消息").getBytes());
        RabbitMQUtil.closeConnectionAndChanel(channel,connection);
    }
}

public class Consumer1 {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMQUtil.getConnection();
        Channel channel = connection.createChannel();
        //声明交换机
        channel.exchangeDeclare("topics","topic");
        //创建临时队列
        String queueName = channel.queueDeclare().getQueue();
        //绑定交换机和队列 动态通配符形式的routerkey
        channel.queueBind(queueName,"topics","user.#");
        channel.basicConsume(queueName,true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者1：" + new String(body));
            }
        });
    }
}

可以看到，消费者能够通过*或#通配符来动态指定routerkey，来匹配生产者user.info.xx这种形式，这样就比direct模型要灵活强大很多。

注：*匹配一个词，#匹配多个。

6.RPC模型

RPC模型并不适用于消息队列，而是用于RPC通信，所以这里就暂时不进行学习了。
7.PublisherConfirms（发布和订阅模型）

这是新出的一种模型，并没有得到广泛使用，也暂时不学习了。

三、Spirngboot整合RabbitMQ

和jdbc一样，rabbitmq的这种原始方式虽然可用，但是同样会产生大量样板代码，所以Springboot封装了一套东西供我们使用（所以上面这么多内容时闹什么呢……）。

1.初来乍到Hello直连模型

使用RabbitTemplate可以轻松发送消息：

@SpringBootTest(classes = RabbitMQApplication.class)
@RunWith(SpringRunner.class)
public class TestRabbitMQ {
    @Autowired
    private RabbitTemplate rabbitTemplate;
    @Test
    public void test(){
        rabbitTemplate.convertAndSend("hello","helloworld");
    }
}

在消费者类上使用注解@RabbitListener可以监听消息，具体使用如下：

@Component
//声明并创建队列
@RabbitListener(queuesToDeclare = @Queue(value = "hello"))
//也可以设置队列是否持久化、是否自动删除等参数
//@RabbitListener(queuesToDeclare = @Queue(value = "hello",durable = "false",autoDelete = "true"))
public class HelloConsumer {
    //具体接收消息的方法
    @RabbitHandler
    public void receivel(String message){
        System.out.println("message: " + message);
    }
}

2.Work模型

@RabbitListener不止可以用在类上，还可以用在方法上，表明这个方法就是一个消费者，这样就能造出多个消费者，实现Work模型了。

//work模型
    @Test
    public void testWork(){
        for (int i = 0;i < 10;i++){
            rabbitTemplate.convertAndSend("work","work模型" + i);
        }
    }

@Component
public class WorkConsumer {
    @RabbitListener(queuesToDeclare = @Queue("work"))
    public void receiver1(String message){
        System.out.println("消费者1：" + message);
    }
    @RabbitListener(queuesToDeclare = @Queue("work"))
    public void receiver2(String message){
        System.out.println("消费者2：" + message);
    }
}

3.Fanout广播模型

//Fanout模型
    @Test
    public void testFanout(){
        rabbitTemplate.convertAndSend("logs","","Fanout广播模型");
    }

@Component
public class FanoutConsumer {
    @RabbitListener(bindings = {
            @QueueBinding(value = @Queue,//创建临时队列
                    exchange = @Exchange(value = "logs",type = "fanout"))//绑定交换机
    })
    public void receive1(String message){
        System.out.println("消费者1：" + message);
    }
    @RabbitListener(bindings = {
            @QueueBinding(value = @Queue,//创建临时队列
                    exchange = @Exchange(value = "logs",type = "fanout"))//绑定交换机
    })
    public void receive2(String message){
        System.out.println("消费者2：" + message);
    }
}

4.路由direct模型

    //路由direct模型
    @Test
    public void testDirect(){
        rabbitTemplate.convertAndSend("directs","info","路由direct模型");
    }

@Component
public class DirectConsumer {
    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue,
                    exchange = @Exchange(value = "directs",type = "direct"),
                    key = {"info","error","warn"}
            )
    })
    public void receiv1(String message){
        System.out.println("消费者1：" + message);
    }
    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue,
                    exchange = @Exchange(value = "directs",type = "direct"),
                    key = {"error"}
            )
    })
    public void receiv2(String message){
        System.out.println("消费者2：" + message);
    }
}

5.动态路由topic模型

//动态路由topic模型
    @Test
    public void testTopic(){
        rabbitTemplate.convertAndSend("topics","user.save","动态路由topic模型");
    }

@Component
public class TopicConsumer {
    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue,
                    exchange = @Exchange(type = "topic",name = "topics"),
                    key = {"user.save","user.*"}
            )
    })
    public void receive1(String message){
        System.out.println("消费者1：" + message);
    }
    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue,
                    exchange = @Exchange(type = "topic",name = "topics"),
                    key = {"user.delete"}
            )
    })
    public void receive2(String message){
        System.out.println("消费者2：" + message);
    }
}

四、RabbitMQ集群

待更新……

四叶猫

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
RabbitMQ入门笔记

什么是消息队列？顾名思义，消息队列就是一个能够存放消息的队列，通常有一个生产者生产消息，一个或多个消费者消费消息。消息队列在分布式系统中运用十分广泛，有异步处理、应用解耦、流量削峰等用途。当然，RabbitMQ不是消息队列的唯一选择，除它以外还有在大数据中十分常见的Kafka、阿里的RocketMQ、Apache的ActiveMQ，甚至Redis也可以当成消息队列使用。不过，正常情况下RabbitMQ是比较通用的选择。RabbitMQ基础模型。
复制链接

扫一扫