RabbitMQ入门

最新推荐文章于 2024-04-13 14:21:05 发布
最新推荐文章于 2024-04-13 14:21:05 发布
阅读量1.9k 收藏
点赞数
文章标签： rabbitmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51809035/article/details/123884036
版权

RabbitMQ入门

文章目录

windows中打开rabbitmq_server-3.9.14的sbin目录，进入cmd

rabbitmqctl stop 停止服务
rabbitmq-server -detached 后台启动（可以关闭cmd窗口）

生产者—交换机—通道channel—queue----消费者

helloworld

public class Provider {

    //生成消息
    @Test
    public void testSendMessage() throws IOException, TimeoutException {

        //创建连接mq的连接工厂对象
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //设置连接rabbitmq主机
        connectionFactory.setHost("127.0.0.1");
        //设置端口号(虚拟主机)
        connectionFactory.setPort(5672);
        //设置连接哪个虚拟主机
        connectionFactory.setVirtualHost("/ems");
        //设置访问虚拟主机的用户名和密码
        connectionFactory.setUsername("ems");
        connectionFactory.setPassword("123");

        //获取连接对象
        Connection connection = connectionFactory.newConnection();

        //通过连接中的通道
        Channel channel = connection.createChannel();

        //通道绑定对应消息队列
        //参数1：队列名字  如果队列不存在自动创建
        //参数2：用来定义队列特性是否要持久化 true持久化队列   false不持久化
        //参数3：exclusive   是否独占队列
        // 参数4：autoDelete 是否在消费完成后自动删除队列
        // 参数5：额外附加参数
        channel.queueDeclare("hello",false,false,false,null);

        //发布消息
        //参数1：交换机名称 参数2：队列名称 参数3：传递消息额外设置  参数4：消息的具体内容
        channel.basicPublish("","hello",null,"hello rabbitmq".getBytes());

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

第一种模式（直连）

消费者：

public class Customer {

    public static void main(String[] args) throws IOException, TimeoutException {
//        ConnectionFactory connectionFactory = new ConnectionFactory();
//        connectionFactory.setHost("127.0.0.1");
//        connectionFactory.setPort(5672);
//        connectionFactory.setVirtualHost("/ems");
//        connectionFactory.setUsername("ems");
//        connectionFactory.setPassword("123");

        //创建连接对象
//        Connection connection = connectionFactory.newConnection();
        Connection connection = RabbitMQUtils.getConnection();

        //创建通道
        Channel channel = connection.createChannel();

        //通道绑定对象
        channel.queueDeclare("hello",false,false,false,null);

        //参数1：消费哪个队列的消息 队列名称
        // 参数2：开启消息的自动确认机制
        // 参数3：消费时的回调接口
        channel.basicConsume("hello",true,new DefaultConsumer(channel){

            //最后一个参数：消息队列中取出的消息
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("new String(body) = "+new String(body));
            }
        });

//        channel.close();;
//        connection.close();
        RabbitMQUtils.closeConnectionAndChanel(channel,connection);
    }
}

工具类：


public class RabbitMQUtils {
    private static ConnectionFactory connectionFactory;

    static {
        //重量级资源，类加载只执行一次
        connectionFactory=new ConnectionFactory();
        connectionFactory.setHost("127.0.0.1");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/ems");
        connectionFactory.setUsername("ems");
        connectionFactory.setPassword("123");
    }

    public static Connection getConnection(){
        try {
            //创建连接对象
            Connection connection = connectionFactory.newConnection();

            //创建通道
            Channel channel = connection.createChannel();
            return connection;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    public static void closeConnectionAndChanel(Channel channel,Connection conn){
        try {
            if(channel!=null)
                channel.close();
            if(conn!=null)
                conn.close();
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

同一个通道channel可以发送到不同的队列

//注意第一个创建并绑定的队列是aa
//但发送到的队列是hello

		//通道绑定对应消息队列
        //参数1：队列名字  如果队列不存在自动创建
        //参数2：用来定义队列特性是否要持久化 true持久化队列   false不持久化
        //参数3：exclusive   是否独占队列
        // 参数4：autoDelete 是否在消费完成后自动删除队列
        // 参数5：额外附加参数
  		channel.queueDeclare("aa",false,false,false,null);

        //发布消息
        //参数1：交换机名称 参数2：队列名称 参数3：传递消息额外设置  参数4：消息的具体内容
        channel.basicPublish("","hello",null,"hello rabbitmq".getBytes());
		//MessageProperties.PERSISTENT_TEXT_PLAIN : 队列里面的消息也要持久化
        channel.basicPublish("","aa", MessageProperties.PERSISTENT_TEXT_PLAIN,"hello rabbitmq".getBytes());

在这里插入图片描述

消费者和生产者的队列创建参数要一样

第二种模式（work queue）

多个消费者 绑定 一个队列

在这里插入图片描述

work模型中，消费者是轮流获取队列中的消息


public class Customer1 {
    public static void main(String[] args) throws IOException {
        //获取连接
        Connection connection = RabbitMQUtils.getConnection();
        final Channel channel = connection.createChannel();

		//一次只接收1条消息
        channel.basicQos(1);

        channel.queueDeclare("work",true,false,false,null);

        //参数2：自动确认
        //rabbitmq会自动分配，如5个完整数据，消费了3个数据，结果自己宕机了，则2个消息丢失
        //我们希望没有消费的消息交给其他Customer
        channel.basicConsume("work",false,new DefaultConsumer(channel){

            //最后一个参数：消息队列中取出的消息
            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 Customer2 {
    public static void main(String[] args) throws IOException {
        //获取连接
        Connection connection = RabbitMQUtils.getConnection();
        final Channel channel = connection.createChannel();

        channel.basicQos(1);

        channel.queueDeclare("work",true,false,false,null);

        channel.basicConsume("work",false,new DefaultConsumer(channel){

            //最后一个参数：消息队列中取出的消息
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者2 = "+new String(body));

                //手动确认  参数1：手动确认消息标识  参数2；false 每次确认一个
                channel.basicAck(envelope.getDeliveryTag(),false);
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
    }
}

生产者：

public class Provider {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMQUtils.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare("work",true,false,false,null);

        for (int i = 0; i < 20; i++) {
            //生产消息
            channel.basicPublish("","work",null,(i+" hello work queue").getBytes());
        }
        //关闭资源
        RabbitMQUtils.closeConnectionAndChanel(channel,connection);
    }
}

在这里插入图片描述

在这里插入图片描述

第三种模式（fanout）扇出，也称 广播

需要交换机（前两种模式使用的默认的交换机）
在这里插入图片描述
交换机决定把消息发给哪个队列，生产者无法决定

由于是广播，所以生产者生成一条，消费者都可以拿到

生产者：


public class Provider {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMQUtils.getConnection();

        Channel channel = connection.createChannel();

        //将通道声明指定交换机    参数1：交换机名字   参数2：交换机类型
        channel.exchangeDeclare("logs","fanout");

        //发送消息      参数2：路由键 参数3：props
        channel.basicPublish("logs","",null,"fanout type message".getBytes());

        //释放资源
        RabbitMQUtils.closeConnectionAndChanel(channel,connection);
    }
}

消费者1：

public class Customer1 {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMQUtils.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){
            //最后一个参数：消息队列中取出的消息
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者1 = "+new String(body));
            }
        });
    }
}

消费者2：

public class Customer2 {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMQUtils.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){
            //最后一个参数：消息队列中取出的消息
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者2 = "+new String(body));
            }
        });
    }
}

第四种情况 路由（Routing）

Routing之订阅模式-Direct（直连）

在Fanout模式中，一条信息会被所有订阅的队列消费，但是，在某些场景下，我们希望不同的消息被不同的队列消费，这是就要用到Direct类型的Exchangel

队列和交换机的绑定需要指定一个路由key
生产者：定义路由key

  //发送消息      参数2：路由键 参数3：props
        channel.basicPublish("logs","",null,"fanout type message".getBytes());

在这里插入图片描述

第五种情况 动态路由 topics

通配符

注意这里生产者创建交换机和消费者绑定交换机时 交换机类型是 topic

只是在生产者绑定路由键时加上*或#

消费者1：

public class Customer1 {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMQUtils.getConnection();
        Channel channel = connection.createChannel();

        //声明交换机以及交换机类型
        channel.exchangeDeclare("topics","topic");
        String queue = channel.queueDeclare().getQueue();
        //绑定队列和交换机 动态通配符route key
        channel.queueBind(queue,"topics","user.*");

        //消费消息
        channel.basicConsume(queue,true,new DefaultConsumer(channel){
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者1 = "+new String(body));
            }
        });
    }
}

消费者2：

public class Customer2 {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMQUtils.getConnection();
        Channel channel = connection.createChannel();

        //声明交换机以及交换机类型
        channel.exchangeDeclare("topics","topic");
        String queue = channel.queueDeclare().getQueue();
        //绑定队列和交换机 动态通配符route key
        channel.queueBind(queue,"topics","user.#");

        //消费消息
        channel.basicConsume(queue,true,new DefaultConsumer(channel){
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者2 = "+new String(body));
            }
        });
    }
}

生产者：

public class Provider {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMQUtils.getConnection();
        Channel channel = connection.createChannel();

        //声明交换机以及交换机类型 topic
        channel.exchangeDeclare("topics","topic");

        //发布消息
        String routekey="user.save.findAll";

        channel.basicPublish("topics",routekey,null,("这里是topic动态路由模型，routekey = "+routekey).getBytes());

        RabbitMQUtils.closeConnectionAndChanel(channel,connection);

    }
}

整合SpringBoot

创建springboot
导入依赖

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

spring:
  application:
    name: rabbitmq-springboot
  rabbitmq:
    host: 127.0.0.1
    port: 5672
    password: 123
    username: ems
    virtual-host: /ems

RabbitTemplate 用来简化操作，使用的时候直接在项目中注入
类似于RedisTemplate

HelloWorld

消费者：

@Component      //持久化  非独占  不是自动删除队列
@RabbitListener(queuesToDeclare = @Queue(value = "hello"))
public class HelloCustomer {

    @RabbitHandler
    public void receive1(String message){
        System.out.println("-------message = "+message);
    }
}

生产者：

@SpringBootTest
class RabbitmqSpringbootApplicationTests {

    //注入RabbitTemplate
    @Autowired
    private RabbitTemplate rabbitTemplate;
//    队列的创建和消费者、发布者没有任何关系，有需要就可以创建，还有这里的routingkey和queueName是完全不同的两个概念，这里他都混为一谈了，很容易让大家混淆
    @Test
    void contextLoads() {
        rabbitTemplate.convertAndSend("hello","hello world");
    }
}

如果没有消费者只有生产者，队列不会出现

work queue

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

@Component
public class WorkCustomer {

    //第一个消费者
    @RabbitListener(queuesToDeclare = @Queue("work"))
    public void receive1(String message){
        System.out.println("message1 = "+message);
    }

    //第二个消费者
    @RabbitListener(queuesToDeclare = @Queue("work"))
    public void receive2(String message){
        System.out.println("message2 = "+message);
    }
}

fanout

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

@Component
public class FanoutCustomer {

    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue,//创建临时队列
                    exchange = @Exchange(value = "logs",type = "fanout")//绑定交换机
            )
    })
    public void receive1(String message){
        System.out.println("message1 = "+message);
    }

    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue,//创建临时队列
                    exchange = @Exchange(value = "logs",type = "fanout")//绑定交换机
            )
    })
    public void receive2(String message){
        System.out.println("message2 = "+message);
    }
}

路由route

    //route 路由
    @Test
    public void testRoute(){
        rabbitTemplate.convertAndSend("directs","error","发送info的key的路由信息");
    }

@Component
public class RouteCustomer {

    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue,
                    exchange = @Exchange(value = "directs",type = "direct"), //指定交换机名称和类型
                    key = {"info","error","warn"}
            )
    })
    public void receive1(String message){
        System.out.println("-------message1 = "+message);
    }

    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue,
                    exchange = @Exchange(value = "directs",type = "direct"), //指定交换机名称和类型
                    key = {"info"}
            )
    })
    public void receive2(String message){
        System.out.println("-------message2 = "+message);
    }
}

动态路由

    //topic
    @Test
    public void testTopic(){
        rabbitTemplate.convertAndSend("topics","user.save","user.save的路由信息");
    }

@Component
public class TopicCustomer {

    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue,
                    exchange = @Exchange(type = "topic",value = "topics"),
                    key = {"user.*"}
            )
    })
    public void receive1(String message){
        System.out.println("-------message1 = "+message);
    }

    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue,
                    exchange = @Exchange(type = "topic",name = "topics"),
                    key = {"user.#"}
            )
    })
    public void receive2(String message){
        System.out.println("-------message2 = "+message);
    }
}
猴子会跳舞
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Rabbit架构篇 - ConnectionFactory
The Secret
10-14 4482
本文介绍Rabbit架构中的ConnectionFactory模型的相关源码。
RabbitMQ工作模式
凉茶铺的博客
04-10 1141
使用代码演示了与介绍了RabbitMQ的五种工作模式
RabbitMQ入门二
梦中注定的博客
07-12 465
RabbitMQ入门二 RabbitMQ高级特性 RabbitMQ应用问题 RabbitMQ集群搭建 1 RabbitMQ高级特性 1.1 消息可靠性投递 ​ 在使用 RabbitMQ 的时候，作为消息发送方希望杜绝任何消息丢失或者投递失败场景。RabbitMQ 为我们提供了两种方式用来控制消息的投递可靠性模式。 confirm 确认模式 return 退回模式 rabbitmq 整个消息投递的路径为： producer—>rabbitmq broker—>exchange—&gt
SpingBoot集成Rabbitmq及Docker部署，项目实战
最新发布
2301_79772893的博客
04-13 916
RabbitMQ是由Erlang语言开发的AMQP的开源实现AMQP：Advanced Message Queue，高级消息队列协议。它是应用层协议的一个开放标准，为面向消息的中间件设计，基于此协议的客户端与消息中间件可传递消息，并不受产品、开发语言等条件的限制。
RabbitMQ-客户端源码之ConnectionFactory
二师兄撒欢之地
01-27 728
之后if(isAutomaticRecoveryEnabled()){}之内的方法是建立可自动恢复连接的，这个可以忽略，直接看else里面的代码，因为if和else大体功能上一致，else里的更通用一些，也是默认的。”返回的是SocketFrameHandler对象，这个对象是对Socket的一个封装，完全可以看成是一个Socket对象。这个是用来处理client与broker之间的通信帧（Frame）的，包括建立通信链路（java的原生socket，注意这里没有NIO也没有netty）。
RabbitMQ客户端源码分析(一)之Connection与ConnectionFactory(好几篇可以分别查看)
gb4215287的博客
04-05 828
文章目录 版本声明 Connection 连接过程分析 连接过程抓包分析 源码分析 ConnectionFactory AMQConnection分析 版本声明 com.rabbitmq:amqp-client:4.3.0 RabbitMQ版本声明: 3.6.15 Connection 这里的连接其实就表示的是TCP/IP socket连接，一个Connection有多个Channel,意味Connection会被设计为长连接，并且每个Channel一定有一个唯一标识，客户端请求和服务端响应都会携带这个标识
rabbitMq入门
08-08
NULL 博文链接：https://zhaoshijie.iteye.com/blog/2161345
RabbitMQ入门视频
04-05
RabbitMQ入门视频
Rabbitmq入门到精通.doc
08-21
Rabbitmq入门到精通全套教程
rabbitmq 入门教程
07-23
RabbitMQ 入门教程 RabbitMQ 是一个消息服务器，负责接收生产者生产的消息，并将其发送给消费者。在这个过程中，RabbitMQ 可以根据用户给定的规则来路由、缓存、持久化这些消息。下面是 RabbitMQ 中的一些专业术语...
RabbitMQ入门案例
05-15
AMQP(advanced message queuing protocol)是一个提供统一消息服务的应用层标准协议，基于此协议的客户端与消息中间件可传递消息，并不受客户端/中间件不同产品，不同开发语言...RabbitMQ（支持更多语言，基于AMQP规范）
RabbitMQ入门教程
08-03
RabbitMQ基础入门教程，是本人查阅相关资料整理而来，作为入门引导，若需要详细的样例可私信我。
RabbitMQ入门到精通笔记
05-02
RabbitMQ是一个开源的遵循 AMQP协议实现的基于 Erlang语言编写，支持多种客户端（语言），用于在分布式系统中存储消息，转发消息，具有高可用，高可扩性，易用性等特征\ RabbitMQ是采用 Erlang语言开发的，所以系统...
RabbitMQ 笔记（一）Connection Factory
qingtianla的博客
08-28 3017
有三个连接工厂可供选择： PooledChannelConnectionFactory ThreadChannelConnectionFactory CachingConnectionFactory 对于大多数用例，应该使用PooledChannelConnectionFactory。如果您希望确保严格的消息顺序而不需要使用作用域操作，则可以使用ThreadChannelConnectionFactory。如果您希望使用相关的发布者确认，或者希望通过其CacheMode打开多个连接，则应该使用Cach
RabbitMQ学习之ConntectionFactory与Conntection的认知
任何技能都是从模仿开始，逐步升华。
11-07 3147
在发送和接收消息重要的类有：ConnectionFactory， Connection，Channel和 QueueingConsumer。 ConntectionFactory类是方便创建与AMQP代理相关联的Connection；下面来看看ConntectionFactory是如何创建一个Contention.首先通过new ConnectionFactory()创建一个Connection
[一]RabbitMQ-客户端源码之ConnectionFactory
weixin_33725722的博客
04-17 731
首先看一段amqp-client发送端的示例代码（展示出主要部分）： ConnectionFactory factory = new ConnectionFactory(); factory.setHost(ip); factory.setPort(5672); factory.setUsername("root"); facto...
rabbitmq入门
07-27
\[3\] RabbitMQ入门指南文章 希望这些信息对你有帮助！ #### 引用[.reference_title] - *1* *2* *3* [超详细的RabbitMQ入门](https://blog.csdn.net/Rok728/article/details/123106242)[target="_blank" data-...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值