从代码认识MQ

最新推荐文章于 2023-10-10 20:45:00 发布
最新推荐文章于 2023-10-10 20:45:00 发布
阅读量270 收藏
点赞数
分类专栏： 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45875389/article/details/119856502
版权

1、什么是MQ

MQ(Message Quene):

翻译为j消息队列,通过典型的生产者和消费者模型生产者不断向消息队列中生产消息，消费者不断的从队列中获取消息。因为消息的生产和消费都是异步的，而且只关心消息的发送和接收，没有业务逻辑的侵入轻松的实现系统间解耦。别名为消息中间件—通过利用高效可靠的消息传递机制进行平台无关的数据交流，并基于数据通信来进行分布式系统的集成。

#1.ActiveMQ

ActiveNQ是Apache出品，最流行的，能力强劲的开源消息总线。它是一个完全支持JNS规范的的消息中间件。丰富的APT,多种集群架构模式让ActivelQ在业界成为老牌的消息中间件,在中小型企业颇受欢迎!

#2.Kafka

Kafka是LinkedIn开源的分布式发布-订阅消息系统，目前归属于Apache顶级项目。Kafka主要特点是基于Pull的模式来处理消息消费,追求高吞吐量，一开始的目的就是用于日志收集和传输。e.8版本开始支持复制，不支持事务，对消息的重复、丢失、错误没有严格要求，适合产生大量数据的互联网服务的数据收集业务。.

#3.RocketMQ

RocketNQ是阿里开源的消息中间件，它是纯Java开发，具有高吞吐量、高可用性、适合大规模分布式系统应用的特点。RocketNQ思路起源于Kafka，但并不是Kafka的一个Copy，它对消息的可靠传输及事务性做了优化，目前在阿里集团被广泛应用于交易、充值、流计算、消息推送、日志流式处理、binglog分发等场景。

#4.RabbitMQ

RabbitMQ比Kafila可靠，Kafika更适合10高吞吐的处理，一般应用在大数据日志处理或对实时性〈少量延迟)，可靠性(少量丢数据）要求稍低的场景使用，比如ELK日志收集。

RabbitMQ比Kafila可靠，Kafika更适合IO高吞吐的处理，一般应用在大数据日志处理或对实时性〈少量延迟)，可靠性(少量丢数据）要求稍低的场景使用，比如ELK日志收集。

2、安装配置

官方文档：https://www.rabbitmq.com/download.html

2.1、安装ERlang

2.1.1查看**erlang和rabbitmq的版本对应关系**

image-20210820102836508

第一种模型

image-20210820150952409

image-20210820153917382

最简单的消费模型点对点

package helloword;


import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import org.junit.Test;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Provider {


    @Test
    // 生产消息到消息队列
    public void testSendMessage() throws IOException, TimeoutException {

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

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

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

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

        // 发布消息
        channel.basicPublish("","hello",null,"hello rabbitmq1".getBytes());

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

    }

}

package helloword;

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Customer {

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

        Connection connection = connectionFactory.newConnection();
        Channel channel = connection.createChannel();
        // 通道绑定对象
        channel.queueDeclare("hello",false,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));
            }
        });
        // 一直去监听消息队列中的消息
        // channel.close();
        // connection.close();
    }
    
    // 如果用@Test的话，会进行消费，但是无法处理回调，此时程序已经结束

}

可以发现获取连接的时候，代码都是相同的，可以封装一个工具类

package utils;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

public class RabbitMQUtils {

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

    // 定义提供连接对象的方法
    public static Connection getConnection() {
        try {
            return connectionFactory.newConnection();
        } 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();
        }
    }

}

image-20210820164012526

package workquene;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import utils.RabbitMQUtils;

import java.io.IOException;

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 =1; i<20; i++) {

            channel.basicPublish("","work",null,(i + "hello work quene").getBytes());
        }

        // 关闭资源
        RabbitMQUtils.closeConnectionAndChanel(channel,connection);
    }
}


package workquene;

import com.rabbitmq.client.*;
import utils.RabbitMQUtils;

import java.io.IOException;

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

        channel.queueDeclare("work",true,false,false,null);
        channel.basicConsume("work",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));
            }
        });
    }
}


package workquene;

import com.rabbitmq.client.*;
import utils.RabbitMQUtils;

import java.io.IOException;

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

        channel.queueDeclare("work",true,false,false,null);
        channel.basicConsume("work",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));
            }
        });
    }
}

两个消费者以平均分配的方式进行，如果一个消费者执行的慢，那么就出现一个消费者执行完成等另一个消费者的情况

能者多劳

package workquene;

import com.rabbitmq.client.*;
import utils.RabbitMQUtils;

import java.io.IOException;

public class Customer1 {
    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);
        // 参数2：消息自动确认
        channel.basicConsume("work",false,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {

                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("消费者-1："+new String(body));
                // 参数1：确认队列中哪个具体消息 参数2：是否开启多个消息同时确认
                channel.basicAck(envelope.getDeliveryTag(),false);
            }
        });
    }
}

image-20210820182920225

package fanout;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import utils.RabbitMQUtils;

import java.io.IOException;

public class Provider {

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

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

        // 发送消息
        channel.basicPublish("logs","",null,"fanout type message".getBytes());

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

    }
}


package fanout;

import com.rabbitmq.client.*;
import utils.RabbitMQUtils;

import java.io.IOException;

// 可以复制三份同样的消费者
public class Customer1 {

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

        // 通道绑定交换机
        channel.exchangeDeclare("logs","fanout");

        // 临时队列
        String queue = channel.queueDeclare().getQueue();
        // 绑定交换机和队列
        channel.queueBind(queue,"logs","");

        // 消费消息
        channel.basicConsume(queue,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));
            }
        });

    }
}

结果发现：所有的消费者都接收到了广播

image-20210820211556763

package direct;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import utils.RabbitMQUtils;

import java.io.IOException;

public class Provider {
    public static void main(String[] args) throws IOException {

        Connection connection = RabbitMQUtils.getConnection();
        Channel channel = connection.createChannel();
        channel.exchangeDeclare("logs_direct","direct");
        String routingkey = "error";
        // 通过通道声明交换机
        // 参数1：交换机名称
        // 参数2：direct 路由模式
        channel.basicPublish("logs_direct",routingkey,null,("这是direct模型发布的:["+ routingkey+"]类型").getBytes());

        RabbitMQUtils.closeConnectionAndChanel(channel,connection);


    }

}


package direct;

import com.rabbitmq.client.*;
import utils.RabbitMQUtils;

import java.io.IOException;

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

        // 通道声明交换机以及交换类型
        channel.exchangeDeclare("logs_direct","direct");

        // 临时队列
        String queue = channel.queueDeclare().getQueue();
        // 基于route key绑定交换机和队列
        channel.queueBind(queue,"logs_direct","error");

        channel.basicConsume(queue,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));
            }
        });


    }

}

image-20210820215205531

package topic;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import utils.RabbitMQUtils;

import java.io.IOException;

public class Provider {
    // 动态路由
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMQUtils.getConnection();
        Channel channel = connection.createChannel();
        channel.exchangeDeclare("topics","topic");

        String routekey = "user.find.save";
        channel.basicPublish("topics",routekey,null,("这里是topic动态路由模型，routekey：【"+routekey+"】").getBytes());

        RabbitMQUtils.closeConnectionAndChanel(channel,connection);
    }
}

package topic;

import com.rabbitmq.client.*;
import utils.RabbitMQUtils;

import java.io.IOException;

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();

        channel.queueBind(queue,"topics","user.*");

        channel.basicConsume(queue,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));
            }
        });
    }
}

springboot整合rabbitmq

引入依赖

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

yml配置

spring:
  application:
    name: springboot_rabbitmq
  rabbitmq:
    host: 47.94.156.204
    port: 5672
    username: ems
    password: 123
    virtual-host: /ems

方式一：

@SpringBootTest(classes = RabbitmqSpringbootApplication.class)
@RunWith(SpringRunner.class)
// 生产者
public class TestRabbitMQ {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void test() {
        rabbitTemplate.convertAndSend("hello","hello world");
    }

}

@Component
@RabbitListener(queuesToDeclare = @Queue("hello")) // 可以在@queue中配置持久化、是否自动删除等 ： 默认值 持久化、非独占、不是自动删除的队列
public class HelloCustomer {
	// 消费者
    @RabbitHandler
    public void recivel(String message) {
        System.out.println("message = " + message);
    }

}
mfei8
关注
专栏目录
【几种 mq 的区别及使用案例代码】
学无止境
02-28 423
【几种 mq 的区别及使用案例代码】
MQ - 02 基础篇_通讯协议
小工匠
09-18 6145
从功能上来看，一个最基础的消息队列应该具备生产、存储、消费的能力也就是能完成“生产者把数据发送到 Broker，Broker 收到数据后，持久化存储数据，最后消费者从 Broker 消费数据”的整个流程。我们从这个流程来拆解技术架构，如下图所示，最基础的消息队列应该具备五个模块。通信协议：用来完成客户端（生产者和消费者）和 Broker 之间的通信，比如生产或消费。网络模块：客户端用来发送数据，服务端用来接收数据。存储模块：服务端用来完成持久化数据存储。生产者：完成生产相关的功能。
MQ的分类你知道么？项目中如何选型MQ？
xiangjunyes的博客
11-29 1797
MQ的分类 消息队列已经逐渐成为企业IT系统内部通信的核心手段。它具有低耦合、可靠投递、广播、流量控制、最终一致性等一系列功能，成为异步RPC的主要手段之一。当今市面上有很多主流的消息中间件，如老牌的ActiveMQ、RabbitMQ，炙手可热的Kafka，阿里巴巴自主开发RocketMQ等。 ActiveMQ 是一款非常古老的MQ，太老了 ，我也就不多说了 优点： 单机吞吐量万级，时效性 ms 级，可用性高，基于主从架构实现高可用性，消息可靠性较 低的概率丢失数据 缺点:官方社区现在对 ActiveMQ
Java开发中常用的消息队列工具 ActiveMQ
longzorg_cn的博客
04-17 908
同类产品： RabbitMQ 、 Kafka、Redis（List）
java判断mq是否可用_MQ消息机制如何确认消费了消息？
weixin_31269985的博客
02-26 1054
消息队列如何保证消息能百分百成功被消费目前常用的消息队列有很多种,如RabbitMQ,ActiveMQ,Kafka...下面以RabbitMQ为例来讲如何保证消息队列中的信息能百分百被消费掉.其中消费队列的工作流程如下:.我们可以再增加一个机制,增加一个确认机制：流程解释:1)订单服务生产者再投递消息之前，先把消息持久化到Redis或DB中，建议redis，高性能。消息的状态为发送中。2)conf...
RabbitMQ消费和生产代码示例
xiaonanlonglong的博客
08-13 549
RabbitMQ消费和生产代码示例
MQ - 40 连接器：以MQ Connector为核心搭建数据集成架构的方案设计
最新发布
小工匠
10-10 5352
在消息队列中，连接器也称为 Connector，它的作用是把不同数据源中的数据导入到消息队列，或者把消息队列中的数据导出到下游的各种存储引擎。连接器对于用户的价值是，可以很方便地将数据导入、导出消息队列。听起来，它和MQ - 38 Serverless : 基于Serverless架构实现流式数据处理中讲的基于 Serverless 实现流式计算和事件驱动架构的作用很类似，从功能上看，Flink 或 Spark 也能实现。那为什么还有连接器这个概念呢？它的价值是什么？
mq补偿机制java代码_RocketMQ源码分析之消息消费机制-消费端消息负载均衡机制与重新分布 - Java 技术驿站-Java 技术驿站...
weixin_32296949的博客
03-02 487
1、消息消费需要解决的问题首先再次重复啰嗦一下RocketMQ消息消费的一些基本元素的关系主题 ---》 消息队列(MessageQueue) 1 对多主题 ----》 消息生产者，，，一般主题会由多个生产者组成，生产者组主题 ---- 》 消息消费者，，一般一个主题也会被多个消费者消费那消息消费至少需要解决如下问题：1、一个消费组中多个消费者是如何对消息队列(1个主题多个消息队列)进行负载消费的...
MQ - 39 Serverless : 基于MQ和Serverless设计事件驱动架构
小工匠
10-09 5515
为了更好地理解它，我们先来回顾两个知识点。MQ - 07 基础篇_消费者客户端SDK设计(上)消费数据时 Push 模型的实时性是最高的MQ - 38 Serverless : 基于Serverless架构实现流式数据处理事件源数据的触发方式有一种是事件触发。从技术上来看，这两个知识点都是事件驱动架构的一种实现。接下来我们就详细了解一下什么是事件驱动架构，它有什么用，以及它的架构和底层运行原理。事件驱动架构，英文是 Event Driven Architecture，简称 EDA。
java mq干嘛用的_MQ适用于哪些业务场景？MQ有什么用？
weixin_30785057的博客
02-26 2170
MQ适用于哪些业务场景？MQ有什么用？MQ的优点和缺点都有哪些？开始今天起，我们会陆续开始一些新的文章系列，和Spring系列并行。学习，也要换换脑子，一天天的看源码，万一看吐子怎么办？隔壁的小妹妹会嫌弃我的。啥是MQA：你能给我解释了下MQ吗？B：MQ就是消息队列。A：嗯，不错，然后呢？B：没了。A：……MQ，英文全拼为message queue，直译为消息队列。一个队列，用来存放消息。纳尼？难...
mq如何查看消费者是谁
fen_dou_shao_nian的博客
02-17 2589
背景 在mq页面，如果这个队列没有消费者，那么它可能十有八九有问题，那么，如果有消费者，如何确定这个消费者是谁呢？ 步骤 lsof -i:30154
如何查看项目中哪里用到了Dubbo&RabbitMQ
qq_41634872的博客
07-01 822
Dubbo: 配置文件：spring-dubbo.xml @Service: 在实现类处的注解 @Reference 自动注入的注解 RabbitMQ 配置文件：spring-rabbit.xml AmqpTemplate:发送消息相关的类 MesangeListener：监听消息队列相关的类
MQ工具类
weixin_39282621的博客
05-11 522
mq工具类提取
MQ报错代码
weixin_33915554的博客
10-14 3493
2019独角兽企业重金招聘Python工程师标准>>> ...
java 读取mq_java获取rabbitmq服务的统计信息
weixin_34142444的博客
02-25 701
String rabbitmqHost = "192.168.0.100";String rabbitmqPort = "15672";String userName = "xxxx";String password = "password";String url = String.format("http://%s:%s/api/overview",rabbitmqHost,rabbitmqPo...
JAVA发送接收MQ代码示例
大胡子康贝勒爷
04-16 2万+
上几篇关于MQ的博客里，并没有介绍的透彻，今天我把用到的类整理到里一起，集成了监视、查找、发送、接收、保存报文的功能。首先，新建TemoteTest类申明： private static MQQueueManager qMgr; // 队列管理器名称 private static MQQueue qQueue; // 消息通道 private static String Q_M
mq的基本介绍和基本用法
zhoujiyu123的专栏
12-05 1万+
一 、什么是MQ，有什么用  MQ 是message queue ,消息队列，也叫消息中间件，遵守JMS（java message service）规范的一种软件。(同时还有另一个叫AMQP的应用层协议，语言无关性不受产品 语言等限制，rabbitMQ支持这个 ) 是类似于数据库一样需要独立部署在服务器上的一种应用，提供接口给其他系统调用。 主要用于各个系统之间通信的解耦。 二、MQ是干嘛...
【1LineCode】一行代码节流防抖
热门推荐
qq_33807889的博客
02-27 3万+
const debounce = (fn,timeout = 1000,_timer) => (...args)=>clearTimeout(_timer(_timer = setTimeout(fn.bind(this,...args),timeout))) const throttle = (fn,timeout = 1000,_flag=true) => (...args)=>_flag &&setTimeout(()=>{_flag = true;.
到底什么时候该使用MQ？
shenjian58的博客
04-05 3617
一、缘起一切脱离业务的架构设计与新技术引入都是耍流氓。引入一个技术之前，首先应该解答的问题是，这个技术解决什么问题。就像微服务分层架构之前，应该首先回答，为什么要引入微...
MQ错误代码详解与参考表
本文档详细介绍了IBM MQ（Message Queuing）错误代码（Reason Code）的概念、用法和分类。MQ Reason Code是与完成代码（Completion Code）一起使用的资格参数，用于提供有关操作结果的额外信息。当调用成功时，返回...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值