【技术解析】消息中间件MQ：从原理到RabbitMQ实战(深入浅出)

news2024/9/19 7:54:11

文章目录

  • 【技术解析】消息中间件MQ：从原理到RabbitMQ实战(深入浅出)
    • 1.简介
      • 1.1 什么是消息中间件
      • 1.2 传统的http请求存在那些缺点
      • 1.3 Mq应用场景有那些
      • 1.4 为什么需要使用mq
      • 1.5 Mq与多线程之间区别
      • 1.6 Mq消息中间件名词
      • 1.7主流mq区别对比
      • 1.8 Mq设计基础知识
    • 2.RabbitMQ
      • 2.1 RabbitMQ环境的基本安装
      • 2.2 liunx安装rabbitmq
      • 2.3快速入门RabbitMQ简单队列
      • 2.4 RabbitMQ如何保证消息不丢失
      • 2.5 RabbitMQ五种消息模式
        • 2.5.1 RabbitMQ Fanout 发布订阅
        • 2.5.2 Direct路由模式
        • 2.5.3 Topic主题模式
      • 2.6 SpringBoot整合RabbitMQ
    • 3. RabbitMQ实战解决方案
      • 3.1 RabbitMQ死信队列
      • 3.2 RabbitMQ消息幂等问题
      • 3.3 SpringBoot开启消息确认机制

【技术解析】消息中间件MQ：从原理到RabbitMQ实战(深入浅出)

1.简介

1.1 什么是消息中间件

消息中间件基于队列模型实现异步/同步传输数据
作用：可以实现支撑高并发、异步解耦、流量削峰、降低耦合度。

1.2 传统的http请求存在那些缺点

  1. Http请求基于请求与响应的模型，在高并发的情况下，客户端发送大量的请求达到
    服务器端有可能会导致我们服务器端处理请求堆积。

  2. Tomcat服务器处理每个请求都有自己独立的线程，如果超过最大线程数会将该请求缓存到队列中，如果请求堆积过多的情况下，有可能会导致tomcat服务器崩溃的问题。所以一般都会在nginx入口实现限流，整合服务保护框架。
    在这里插入图片描述

  3. http请求处理业务逻辑如果比较耗时的情况下，容易造成客户端一直等待，阻塞等待过程中会导致客户端超时发生重试策略，有可能会引发幂等性问题。

注意事项：接口是为http协议的情况下，最好不要处理比较耗时的业务逻辑，耗时的业务逻辑应该单独交给多线程或者是mq处理。

1.3 Mq应用场景有那些

  1. 异步发送短信
  2. 异步发送新人优惠券
  3. 处理一些比较耗时的操作

1.4 为什么需要使用mq

可以实现支撑高并发、异步解耦、流量削峰、降低耦合度。

同步发送http请求
在这里插入图片描述
客户端发送请求到达服务器端，服务器端实现会员注册业务逻辑，

  1. insertMember() --插入会员数据 1s
  2. sendSms()----发送登陆短信提醒 3s
  3. sendCoupons()----发送新人优惠券 3s

总共响应需要6s时间，可能会导致客户端阻塞6s时间，对用户体验不是很好。

多线程处理业务逻辑
在这里插入图片描述

用户向数据库中插入一条数据之后，在单独开启一个线程异步发送短信和优惠操作。
客户端只需要等待1s时间
优点：适合于小项目 实现异步
缺点：有可能会消耗服务器cpu资源资源

MQ处理业务逻辑
在这里插入图片描述
先向数据库中插入一条会员数据，让后再向MQ中投递一个消息，MQ服务器端在将消息推送给消费者异步解耦处理发送短信和优惠券。

1.5 Mq与多线程之间区别

MQ可以实现异步/解耦/流量削峰问题；
多线程也可以实现异步，但是消耗到cpu资源，没有实现解耦。

1.6 Mq消息中间件名词

Producer 生产者：投递消息到MQ服务器端；
Consumer 消费者：从MQ服务器端获取消息处理业务逻辑；
Broker MQ服务器端
Topic 主题：分类业务逻辑发送短信主题、发送优惠券主题
Queue 存放消息模型 队列 先进先出 后进后出原则 数组/链表
Message 生产者投递消息报文：json

1.7主流mq区别对比

特性ActiveMQRabbitMQRocketMQKafka
开发语言javaerlangjavascala
单机吞吐量万级万级10万级10万级
时效性ms级us级ms级ms级以内
可用性高(主从架构)高(主从架构)非常高(分布式架构)非常高(分布式架构)
功能特性成熟的产品，在很多公司得到应用；有较多的文档；各种协议支持较好基于erlang开发，所以并发能力很强，性能极其好，延时很低管理界面较丰富MQ功能比较完备，扩展性佳只支持主要的MQ功能，像一些消息查询，消息回溯等功能没有提供，毕竟是为大数据准备的，在大数据领域应用广。

1.8 Mq设计基础知识

Maven依赖

<dependencies>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.62</version>
    </dependency>

    <dependency>
        <groupId>io.netty</groupId>
        <artifactId>netty-all</artifactId>
        <version>4.0.23.Final</version>
    </dependency>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.62</version>
    </dependency>
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-lang3</artifactId>
        <version>3.11</version>
    </dependency>
</dependencies>

基于多线程队列简单实现mq

public class MayiktThreadMQ {
    private static LinkedBlockingDeque<JSONObject> msgs = new LinkedBlockingDeque<>();

    public static void main(String[] args) {
        //生产者线程
        Thread producerThread = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    while (true){
                        //每隔一秒时间存放一个消息到队列里面去
                        Thread.sleep(1000);
                        JSONObject data = new JSONObject();
                        data.put("userId", "1234");
                        msgs.offer(data);//存入队列
                    }
                } catch (Exception e) {

                }
            }
        }, "生产者");
        producerThread.start();
        //消费者线程
        Thread consumerThread = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    while (true) {
                        JSONObject data = msgs.poll();//取出消息
                        if (data != null) {
                            System.out.println(Thread.currentThread().getName() + "," + data);
                        }
                    }
                } catch (Exception e) {

                }
            }
        }, "消费者");
        consumerThread.start();
    }
}

基于netty实现mq
消费者netty客户端与nettyServer端MQ服务器端保持长连接，MQ服务器端保存消费者连接。
生产者netty客户端发送请求给nettyServer端MQ服务器端，MQ服务器端在将该消息内容发送给消费者。
在这里插入图片描述
body:{"msg":{"userId":"123456","age":"23"},"type":"producer"，”topic”:””}

生产者投递消息给MQ服务器端，MQ服务器端需要缓存该消息如果mq服务器端宕机之后，消息如何保证不丢失

  1. 持久化机制
    如果mq接收到生产者投递消息，如果消费者不在的情况下，该消息是否会丢失？
  • 不会丢失，消息确认机制 必须要消费者消费该消息成功之后，在通知给mq服务器端删除该消息。
  • Mq服务器端将该消息推送消费者：
    • 消费者已经和mq服务器保持长连接。
    • 消费者主动拉取消息：
    • 消费者第一次刚启动的时候

Mq如何实现抗高并发思想

Mq消费者根据自身能力情况 ，拉取mq服务器端消息消费。
默认的情况下是取出一条消息。

缺点：存在延迟的问题

需要考虑mq消费者提高速率的问题：如何消费者提高速率：消费者实现集群、消费者批量获取消息即可。

2.RabbitMQ

RabbitMQ基本介绍
RabbitMQ是实现了高级消息队列协议（AMQP）的开源消息代理软件（亦称面向消息的中间件），RabbitMQ服务器是用Erlang语言编写的。
RabitMQ官方网站
在这里插入图片描述
在这里插入图片描述

https://www.rabbitmq.com/getstarted.html

  1. 点对点(简单)的队列
  2. 工作(公平性)队列模式
  3. 发布订阅模式
  4. 路由模式Routing
  5. 通配符模式Topics
  6. RPC

2.1 RabbitMQ环境的基本安装

  1. 下载并安装erlang,下载地址：http://www.erlang.org/download
  2. 配置erlang环境变量信息
  • 新增环境变量ERLANG_HOME=erlang的安装地址
  • 将%ERLANG_HOME%\bin加入到path中
  1. 下载并安装RabbitMQ，下载地址：http://www.rabbitmq.com/download.html
  • 注意: RabbitMQ 它依赖于Erlang,需要先安装Erlang。
  • https://www.rabbitmq.com/install-windows.html

安装RabbitMQ环境步骤
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

配置Erlang环境变量：
在这里插入图片描述
在这里插入图片描述

安装rabbitmq-server-3.6.9
在这里插入图片描述
在这里插入图片描述

如何启动Rabbitmq
RabbitMQ Service - start

在这里插入图片描述

启动Rabbitmq常见问题
如果rabbitmq 启动成功无法访问 管理平台页面

进入到D:\java\rabbitmq-server-3.6.9\rabbitmq_server-3.6.9\sbin
执行
rabbitmq-plugins enable rabbitmq_management
rabbitmqctl start_app

Rabbitmq管理平台中心
RabbitMQ 管理平台地址 http://127.0.0.1:15672
默认账号:guest/guest 用户可以自己创建新的账号

Virtual Hosts:
像mysql有数据库的概念并且可以指定用户对库和表等操作的权限。那RabbitMQ呢？
RabbitMQ也有类似的权限管理。在RabbitMQ中可以虚拟消息服务器VirtualHost，每个VirtualHost相当月一个相对独立的RabbitMQ服务器，每个VirtualHost之间是相互隔离的。exchange、queue、message不能互通。

默认的端口15672：rabbitmq管理平台端口号
默认的端口5672： rabbitmq消息中间内部通讯的端口
默认的端口号25672 rabbitmq集群的端口号

RabbitMQ常见名词
/Virtual Hosts—分类
/队列 存放我们消息
Exchange 分派我们消息在那个队列存放起来 类似于nginx

15672—rabbitmq控制台管理平台 http协议
25672 rabbitmq 集群通信端口号
Amqp 5672 rabbitmq内部通信的一个端口号
在这里插入图片描述

2.2 liunx安装rabbitmq

# 安装启动rabbitmq容器
docker run -d --name myRabbitMQ -e RABBITMQ_DEFAULT_USER=root -e RABBITMQ_DEFAULT_PASS=0806 -p 15672:15672 -p 5672:5672 rabbitmq:3.8.14-management

-d ：表示以后台（detached）模式运行容器
--name myRabbitMQ ：指定容器的名称为"myRabbitMQ"
-e RABBITMQ_DEFAULT_USER=root -e RABBITMQ_DEFAULT_PASS=0806：设置RabbitMQ的默认用户名为"root"，默认密码为"0806"
-p 15672:15672 -p 5672:5672 ：将容器的15672端口映射到主机的15672端口（用于访问管理界面），将容器的5672端口映射到主机的5672端口（用于消息传输）
rabbitmq:3.8.14-management ：指定使用的RabbitMQ镜像及版本号，这里使用了带管理插件的版本"rabbitmq:3.8.14-management"

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

2.3快速入门RabbitMQ简单队列

首先需要再RabbitMQ平台创建Virtual Hosts 和队列。
/meiteVirtualHosts

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

Maven依赖

<dependencies>
    <dependency>
        <groupId>com.rabbitmq</groupId>
        <artifactId>amqp-client</artifactId>
        <version>3.6.5 </version>
    </dependency>
</dependencies>

RabbitMQConnection

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

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

public class RabbitMQConnection {
    /**
     * 获取链接
     */
    public static Connection getConnection() throws IOException, TimeoutException {
        // 1.创建连接
        ConnectionFactory connectionFactory = new ConnectionFactory();
        // 2.设置连接地址
        connectionFactory.setHost("192.168.249.129");
        // 3.设置端口号
        connectionFactory.setPort(5672);
        // 4.设置账号和密码
        connectionFactory.setUsername("root");
        connectionFactory.setPassword("0806");
        // 5.设置VirtualHost
        connectionFactory.setVirtualHost("/meiteVirtualHosts");
        return connectionFactory.newConnection();
    }
}

生产者

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

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

public class Producer {
/**
     * 生产者
     */
    private static final String QUEUE_NAME = "mayikt-queue";//队列名称

    public static void main(String[] args) throws IOException, TimeoutException {
        //1.创建连接
        Connection connection = RabbitMQConnection.getConnection();
        //2.创建通道
        Channel channel = connection.createChannel();
        String msg = "测试555";
        channel.basicPublish("", QUEUE_NAME, null, msg.getBytes());
        //3.关闭通道和连接
        channel.close();
        connection.close();
    }
}

运行前
在这里插入图片描述
运行后
在这里插入图片描述

mayikt-queue队列里面有一条消息没有被消费者消费(没被消费就会一直在队列中缓存)

import com.rabbitmq.client.*;

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

public class Consume {
    /**
     * 消费者
     */
    private static final String QUEUE_NAME = "mayikt-queue";//队列名称

    public static void main(String[] args) throws IOException, TimeoutException {
        //1.创建连接
        Connection connection = RabbitMQConnection.getConnection();
        //2.设置通道
        Channel channel = connection.createChannel();
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws UnsupportedEncodingException {
                String msg = new String(body, "UTF-8");
                System.out.println("消费者获取消息:" + msg);
            }
        };
        //3.监听队列
        //autoAck ture:自动签收
        //autoAck false:手动签收
        channel.basicConsume(QUEUE_NAME, true, defaultConsumer);
    }
}

若报此错误:Caused by: com.rabbitmq.client.ShutdownSignalException: channel error; protocol method: #method<channel.close>(reply-code=404, reply-text=NOT_FOUND - no queue 'mayikt-queu' in vhost '/meiteVirtualHosts', class-id=60, method-id=20)
证明没有名为此'mayikt-queu'的队列

2.4 RabbitMQ如何保证消息不丢失

Mq如何保证消息不丢失：

  1. 生产者角色
    确保生产者投递消息到MQ服务器端成功。
    Ack 消息确认机制
    同步或者异步的形式
    方式1：Confirms
    方式2：事务消息

  2. 消费者角色
    在rabbitmq情况下：
    必须要将消息消费成功之后，才会将该消息从mq服务器端中移除。
    在kafka中的情况下：
    不管是消费成功还是消费失败，该消息都不会立即从mq服务器端移除。

  3. Mq服务器端 在默认的情况下 都会对队列中的消息实现持久化持久化硬盘。

  • 使用消息确认机制+持久技术
    A.消费者确认收到消息机制
    channel.basicConsume(QUEUE_NAME, false, defaultConsumer);
    注：第二个参数值为false代表关闭RabbitMQ的自动应答机制，改为手动应答。
    在处理完消息时，返回应答状态，true表示为自动应答模式。
    channel.basicAck(envelope.getDeliveryTag(), false);
    B.生产者确认投递消息成功 使用Confirm机制 或者事务消息
    在这里插入图片描述

Confirm机制 同步或者是异步的形式

  • RabbitMQ默认创建是持久化的
    在这里插入图片描述

(durable为持久化到硬盘 Transient为持久化到内存)
代码中设置 durable为true

参数名称详解：
durable是否持久化 durable为持久化、 Transient 不持久化
autoDelete 是否自动删除，当最后一个消费者断开连接之后队列是否自动被删除，可以通过RabbitMQ Management，查看某个队列的消费者数量，当consumers = 0时队列就会自动删除

  • 使用rabbitmq事务消息；
	channel.txSelect();
	channel.basicPublish("", QUEUE_NAME, null, msg.getBytes());
//	  int i = 1 / 0;
	channel.txCommit();

相关核心代码
生产者

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.zhaoli.RabbitMQConnection;

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

public class Producer {
    private static final String QUEUE_NAME = "mayikt-queue";

    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
        //1.创建一个新连接
        Connection connection = RabbitMQConnection.getConnection();
        //2.设置channel
        Channel channel = connection.createChannel();
        //3.发送消息
        String msg = "每特教育6666";
channel.confirmSelect();

        channel.basicPublish("", QUEUE_NAME, null, msg.getBytes());
        boolean result = channel.waitForConfirms();
        if (result) {
            System.out.println("消息投递成功");
        } else {
            System.out.println("消息投递失败");
        }
        channel.close();
        connection.close();
    }
}

消费者

import com.rabbitmq.client.*;
import com.zhaoli.RabbitMQConnection;

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

public class Consumer {
    private static final String QUEUE_NAME = "mayikt-queue";

    public static void main(String[] args) throws IOException, TimeoutException, IOException, TimeoutException {
        // 1.创建连接
        Connection connection = RabbitMQConnection.getConnection();
        // 2.设置通道
        Channel channel = connection.createChannel();
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String msg = new String(body, "UTF-8");
                System.out.println("消费者获取消息:" + msg);
                // 消费者完成 消费该消息
                channel.basicAck(envelope.getDeliveryTag(), false);
            }
        };
        // 3.监听队列
        channel.basicConsume(QUEUE_NAME, false, defaultConsumer);

    }
}

2.5 RabbitMQ五种消息模式

RabitMQ工作队列
默认的传统队列是为均摊消费，存在不公平性；如果每个消费者速度不一样的情况下，均摊消费是不公平的，应该是能者多劳。
在这里插入图片描述

采用工作队列
在通道中只需要设置basicQos为1即可，表示MQ服务器每次只会给消费者推送1条消息必须手动ack确认之后才会继续发送。
channel.basicQos(1);

RabbitMQ交换机类型

交换机类型描述
Direct直连交换机
Fanout扇型交换机
Topic主题交换机
Headers头交换机
/Virtual Hosts—区分不同的团队
----队列 存放消息
----交换机 路由消息存放在那个队列中 类似于nginx
—路由key 分发规则
2.5.1 RabbitMQ Fanout 发布订阅

生产者发送一条消息，经过交换机转发到多个不同的队列，多个不同的队列就多个不同的消费者。
在这里插入图片描述
在这里插入图片描述
原理：

  1. 需要创建两个队列 ，每个队列对应一个消费者；
  2. 队列需要绑定我们交换机
  3. 生产者投递消息到交换机中，交换机在将消息分配给两个队列中都存放起来；
  4. 消费者从队列中获取这个消息。

生产者代码

import com.zhaoli.RabbitMQConnection;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;

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

public class ProducerFanout {//生产者
    /**
     * 定义交换机的名称
     */
    private static final String EXCHANGE_NAME = "fanout_exchange";

    public static void main(String[] args) throws IOException, TimeoutException {
        //  创建Connection
        Connection connection = RabbitMQConnection.getConnection();
        // 创建Channel
        Channel channel = connection.createChannel();
        // 通道关联交换机
        channel.exchangeDeclare(EXCHANGE_NAME, "fanout", true);
        String msg = "赵立6666";
        channel.basicPublish(EXCHANGE_NAME, "", null, msg.getBytes());
        channel.close();
        connection.close();
    }
}

添加交换机
在这里插入图片描述

消费者代码
邮件消费者

import com.rabbitmq.client.*;
import com.zhaoli.RabbitMQConnection;

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

public class MailConsumer {//邮件消费者
    /**
     * 定义邮件队列
     */
    private static final String QUEUE_NAME = "fanout_email_queue";
    /**
     * 定义交换机的名称
     */
    private static final String EXCHANGE_NAME = "fanout_exchange";

    public static void main(String[] args) throws IOException, TimeoutException {
        System.out.println("邮件消费者...");
        // 创建我们的连接
        Connection connection = RabbitMQConnection.getConnection();
        // 创建我们通道
        final Channel channel = connection.createChannel();
        // 关联队列消费者关联队列
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "");
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String msg = new String(body, "UTF-8");
                System.out.println("邮件消费者获取消息:" + msg);
            }
        };
        // 开始监听消息 自动签收
        channel.basicConsume(QUEUE_NAME, true, defaultConsumer);
    }
}

短信消费者

import com.rabbitmq.client.*;
import com.zhaoli.RabbitMQConnection;

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

public class SmsConsumer {//短信消费者
    /**
     * 定义短信队列
     */
    private static final String QUEUE_NAME = "fanout_email_sms";
    /**
     * 定义交换机的名称
     */
    private static final String EXCHANGE_NAME = "fanout_exchange";

    public static void main(String[] args) throws IOException, TimeoutException {
        System.out.println("短信消费者...");
        // 创建我们的连接
        Connection connection = RabbitMQConnection.getConnection();
        // 创建我们通道
        final Channel channel = connection.createChannel();
        // 关联队列消费者关联队列
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "");
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String msg = new String(body, "UTF-8");
                System.out.println("短信消费者获取消息:" + msg);
            }
        };
        // 开始监听消息 自动签收
        channel.basicConsume(QUEUE_NAME, true, defaultConsumer);
    }
}

添加队列
在这里插入图片描述

2.5.2 Direct路由模式

当交换机类型为direct类型时，根据队列绑定的路由建转发到具体的队列中存放消息
在这里插入图片描述

生产者

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.zhaoli.RabbitMQConnection;

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

public class ProducerDirect {

    /**
     * 定义交换机的名称
     */
    private static final String EXCHANGE_NAME = "direct_exchange";

    public static void main(String[] args) throws IOException, TimeoutException {
        //  创建Connection
        Connection connection = RabbitMQConnection.getConnection();
        // 创建Channel
        Channel channel = connection.createChannel();
        // 通道关联交换机
        channel.exchangeDeclare(EXCHANGE_NAME, "direct", true);
        String msg = "每特教育6666";
        channel.basicPublish(EXCHANGE_NAME, "email", null, msg.getBytes());
        channel.close();
        connection.close();
    }
}

添加交换机
在这里插入图片描述

消费者
邮件消费者

import com.rabbitmq.client.*;
import com.zhaoli.RabbitMQConnection;

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

public class MailConsumer {
    /**
     * 定义邮件队列
     */
    private static final String QUEUE_NAME = "direct_email_queue";
    /**
     * 定义交换机的名称
     */
    private static final String EXCHANGE_NAME = "direct_exchange";

    public static void main(String[] args) throws IOException, TimeoutException {
        System.out.println("邮件消费者...");
        // 创建我们的连接
        Connection connection = RabbitMQConnection.getConnection();
        // 创建我们通道
        final Channel channel = connection.createChannel();
        // 关联队列消费者关联队列
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "email");
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String msg = new String(body, "UTF-8");
                System.out.println("邮件消费者获取消息:" + msg);
            }
        };
        // 开始监听消息 自动签收
        channel.basicConsume(QUEUE_NAME, true, defaultConsumer);
    }
}

短信消费者

import com.rabbitmq.client.*;
import com.zhaoli.RabbitMQConnection;

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

public class SmsConsumer {
    /**
     * 定义短信队列
     */
    private static final String QUEUE_NAME = "direct_sms_queue";
    /**
     * 定义交换机的名称
     */
    private static final String EXCHANGE_NAME = "direct_exchange";

    public static void main(String[] args) throws IOException, TimeoutException {
        System.out.println("短信消费者...");
        // 创建我们的连接
        Connection connection = RabbitMQConnection.getConnection();
        // 创建我们通道
        final Channel channel = connection.createChannel();
        // 关联队列消费者关联队列
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "sms");
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String msg = new String(body, "UTF-8");
                System.out.println("短信消费者获取消息:" + msg);
            }
        };
        // 开始监听消息 自动签收
        channel.basicConsume(QUEUE_NAME, true, defaultConsumer);
    }
}

添加队列
在这里插入图片描述
在这里插入图片描述

2.5.3 Topic主题模式

当交换机类型为topic类型时，根据队列绑定的路由建模糊转发到具体的队列中存放。
#号表示支持匹配多个词；
*号表示只能匹配一个词
在这里插入图片描述

生产者

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.zhaoli.RabbitMQConnection;

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

public class ProducerTopic {

    /**
     * 定义交换机的名称
     */
    private static final String EXCHANGE_NAME = "topic_exchange";

    public static void main(String[] args) throws IOException, TimeoutException {
        //  创建Connection
        Connection connection = RabbitMQConnection.getConnection();
        // 创建Channel
        Channel channel = connection.createChannel();
        // 通道关联交换机
        channel.exchangeDeclare(EXCHANGE_NAME, "topic", true);
        String msg = "每特教育6666";
        channel.basicPublish(EXCHANGE_NAME, "mayikt.sms", null, msg.getBytes());
        channel.close();
        connection.close();
    }
}

添加交换机
在这里插入图片描述

消费者
邮件消费者

import com.rabbitmq.client.*;
import com.zhaoli.RabbitMQConnection;

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

public class MailConsumer {
    /**
     * 定义邮件队列
     */
    private static final String QUEUE_NAME = "topic_email_queue";
    /**
     * 定义交换机的名称
     */
    private static final String EXCHANGE_NAME = "topic_exchange";

    public static void main(String[] args) throws IOException, TimeoutException {
        System.out.println("邮件消费者...");
        // 创建我们的连接
        Connection connection = RabbitMQConnection.getConnection();
        // 创建我们通道
        final Channel channel = connection.createChannel();
        // 关联队列消费者关联队列
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "mayikt.*");
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String msg = new String(body, "UTF-8");
                System.out.println("邮件消费者获取消息:" + msg);
            }
        };
        // 开始监听消息 自动签收
        channel.basicConsume(QUEUE_NAME, true, defaultConsumer);
    }
}

短信消费者

import com.rabbitmq.client.*;
import com.zhaoli.RabbitMQConnection;

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

public class SmsConsumer {
    /**
     * 定义短信队列
     */
    private static final String QUEUE_NAME = "topic_sms_queue";
    /**
     * 定义交换机的名称
     */
    private static final String EXCHANGE_NAME = "topic_exchange";

    public static void main(String[] args) throws IOException, TimeoutException {
        System.out.println("短信消费者...");
        // 创建我们的连接
        Connection connection = RabbitMQConnection.getConnection();
        // 创建我们通道
        final Channel channel = connection.createChannel();
        // 关联队列消费者关联队列
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "meite.*");
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String msg = new String(body, "UTF-8");
                System.out.println("短信消费者获取消息:" + msg);
            }
        };
        // 开始监听消息 自动签收
        channel.basicConsume(QUEUE_NAME, true, defaultConsumer);
    }
}

添加队列
在这里插入图片描述在这里插入图片描述

2.6 SpringBoot整合RabbitMQ

Maven依赖

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.0.0.RELEASE</version>
</parent>
<dependencies>

    <!-- springboot-web组件 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- 添加springboot对amqp的支持 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-amqp</artifactId>
    </dependency>
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-lang3</artifactId>
    </dependency>
    <!--fastjson -->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.49</version>
    </dependency>

    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
    </dependency>
</dependencies>

配置类

package com.zhaoli.config;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.FanoutExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;

@Component
public class RabbitMQConfig {
    /**
     * 定义交换机
     */
    private String EXCHANGE_SPRINGBOOT_NAME = "/mayikt_ex";
    /**
     * 短信队列
     */
    private String FANOUT_SMS_QUEUE = "fanout_sms_queue";
    /**
     * 邮件队列
     */
    private String FANOUT_EMAIL_QUEUE = "fanout_email_queue";

    //1.注入队列和交换机到spring容器中
    //2.关联交换机 xml中用的是<bean id="" class="";>  注解用@bean

    /**
     * 邮件队列、短信队列、交换机 注入到spring 容器中
     */
    @Bean
    public Queue smsQueue() {
        return new Queue(FANOUT_SMS_QUEUE);
    }

    @Bean
    public Queue emailQueue() {
        return new Queue(FANOUT_EMAIL_QUEUE);
    }

    @Bean
    public FanoutExchange fanoutExchange() {
        return new FanoutExchange(EXCHANGE_SPRINGBOOT_NAME);
    }

    /**
     * 关联交换机
     * 根据参数名称在 ioc 容器中获取 Queue 对象
     */
    @Bean
    public Binding bindingSmsFanoutExchange(Queue smsQueue, FanoutExchange fanoutExchange) {
        //将 FANOUT_SMS_QUEUE 队列关联 EXCHANGE_SPRINGBOOT_NAME 交换机
        return BindingBuilder.bind(smsQueue).to(fanoutExchange);
    }

    @Bean
    public Binding bindingEmailFanoutExchange(Queue emailQueue, FanoutExchange fanoutExchange) {
        //将 FANOUT_EMAIL_QUEUE 队列关联 EXCHANGE_SPRINGBOOT_NAME 交换机
        return BindingBuilder.bind(emailQueue).to(fanoutExchange);
    }
}

在这里插入图片描述

配置文件

Resources/application.yml
spring:
  rabbitmq:
    ####连接地址
    host: 192.168.249.129
    ####端口号
    port: 5672
    ####账号
    username: guest
    ####密码
    password: guest
    ### 地址
    virtual-host: /meiteVirtualHosts

配置账号访问权限
在这里插入图片描述

Entity

package com.zhaoli.entity;

import lombok.Data;

import java.io.Serializable;

@Data
public class MsgEntity implements Serializable {
    private String msgId;
    private String userId;
    private String phone;
    private String email;

    public MsgEntity(String msgId, String userId, String phone, String email) {
        this.msgId = msgId;
        this.userId = userId;
        this.phone = phone;
        this.email = email;
    }
}

启动类

package com.zhaoli;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class AppProducer {
    public static void main(String[] args) {
        SpringApplication.run(AppProducer.class);
    }
}

生产者

package com.zhaoli.service;

import com.zhaoli.entity.MsgEntity;
import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.UUID;

@RestController
public class ProducerService {

    /**
     * 从 springboot ioc 容器中拿到整合好的 rabbitmq 中的 AmqpTemplate 模板
     */
    @Autowired
    private AmqpTemplate amqpTemplate;

    @RequestMapping("/sendMsg")
    public void sendMsg() {
        MsgEntity msgEntity = new MsgEntity(UUID.randomUUID().toString(), "1234", "1764654557", "5204567891@qq.com");
        /**
         * 参数1 交换机名称
         * 参数2 路由 key
         * 参数3 发送内容
         */
        amqpTemplate.convertAndSend("/mayikt_ex", "", msgEntity);
    }
}

在这里插入图片描述

消费者

package com.zhaoli;

import com.zhaoli.entity.MsgEntity;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Slf4j
@Component
@RabbitListener(queues = "fanout_email_queue")
public class FanoutEmailConsumer {
    @RabbitHandler
    public void process(MsgEntity msgEntity) {
        log.info("email:msgEntity:" + msgEntity);
    }
}
package com.zhaoli;

import com.zhaoli.entity.MsgEntity;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Slf4j
@Component
@RabbitListener(queues = "fanout_sms_queue")
public class FanoutSmsConsumer {
    @RabbitHandler
    public void process(MsgEntity msgEntity) {
        log.info("sms:msgEntity:" + msgEntity);
    }
}

在配置文件 Resources/application.yml 中设置一个新的端口号，避免同时启动端口号冲突

server:
  port: 8082

整个项目结构

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

生产者如何获取消费结果

  1. 根据业务来定
    消费者消费成功结果：
    能够在数据库中插入一条数据

  2. Rocketmq 自带全局消息id，能够根据该全局消息获取消费结果
    原理： 生产者投递消息到mq服务器，mq服务器端在这时候返回一个全局的消息id，
    当我们消费者消费该消息成功之后，消费者会给我们mq服务器端发送通知标记该消息
    消费成功。
    生产者获取到该消息全局id，每隔2s时间调用mq服务器端接口查询该消息是否
    有被消费成功。

  3. 异步返回一个全局id，前端使用ajax定时主动查询；

  4. 在rocketmq中，自带根据消息id查询是否消费成功

3. RabbitMQ实战解决方案

3.1 RabbitMQ死信队列

死信队列产生的背景
RabbitMQ死信队列俗称，备胎队列；消息中间件因为某种原因拒收该消息后，可以转移到死信队列中存放，死信队列也可以有交换机和路由key等。

产生死信队列的原因

  1. 消息投递到MQ中存放 消息已经过期 消费者没有及时的获取到我们消息，消息如果存放到mq服务器中过期之后，会转移到备胎死信队列存放。
  2. 队列达到最大的长度 （队列容器已经满了）
  3. 消费者消费多次消息失败，就会转移存放到死信队列中
    在这里插入图片描述

代码整合 参考 mayikt-springboot-rabbitmq|#中order-dead-letter-queue项目

死信队列的架构原理
死信队列和普通队列区别不是很大，普通与死信队列都有自己独立的交换机和路由key、队列和消费者。
区别：

  1. 生产者投递消息先投递到我们普通交换机中，普通交换机在将该消息投到普通队列中缓存起来，普通队列对应有自己独立普通消费者。
  2. 如果生产者投递消息到普通队列中，普通队列发现该消息一直没有被消费者消费的情况下，在这时候会将该消息转移到死信（备胎）交换机中，死信（备胎）交换机对应有自己独立的 死信（备胎）队列 对应独立死信（备胎）消费者。

死信队列应用场景
30分钟订单超时设计
A.Redis过期key ：
在设计 Redis 的过期 key 时，可以使用 Redis 的过期时间特性来自动删除超时的订单。可以通过以下步骤实现：

  1. 创建订单时，生成一个唯一的订单 ID。
  2. 将订单 ID 作为 Redis 键（key）。例如，可以使用 “order:{订单ID}” 这样的键命名格式。
  3. 在订单创建完成后，设置 Redis 键的过期时间（TTL）为 30 分钟。可以使用 Redis 命令 EXPIRE 或 SETEX 设置过期时间。
  4. 当需要检查订单是否超时时，可以使用 Redis 的 TTL 命令来查看键的剩余生存时间。如果返回值小于 0，说明订单已超时。
  5. 如果订单超时，则根据业务需求执行相应的处理操作，例如取消订单、发送通知等。
    通过以上设计，Redis 会自动管理订单的过期与删除，避免了手动操作，并且可以提高订单过期检查的效率。

B.死信延迟队列实现：
采用死信队列，创建一个普通队列没有对应的消费者消费消息，在30分钟过后就会将该消息转移到死信备胎消费者实现消费。
备胎死信消费者会根据该订单号码查询是否已经支付过，如果没有支付的情况下则会开始回滚库存操作。

3.2 RabbitMQ消息幂等问题

RabbitMQ消息自动重试机制

  1. 当我们消费者处理执行我们业务代码的时候，如果抛出异常的情况下在这时候mq会自动触发重试机制，默认的情况下rabbitmq是无限次数的重试需要人为指定重试次数限制问题
  2. 在什么情况下消费者需要实现重试策略？
    A.消费者获取消息后，调用第三方接口，但是调用第三方接口失败呢？是否需要重试？
    该情况下需要实现重试策略，网络延迟只是暂时调用不通，重试多次有可能会调用通。

B.消费者获取消息后，因为代码问题抛出数据异常，是否需要重试？
该情况下是不需要实现重试策略，就算重试多次，最终还是失败的，可以将日志存放起来，后期通过定时任务或者人工补偿形式。
如果是重试多次还是失败消息，需要重新发布消费者版本实现消费。
可以使用死信队列。

Mq在重试的过程中，有可能会引发消费者重复消费的问题。
Mq消费者需要解决 幂等性问题
幂等性 保证数据唯一

方式1：
生产者在投递消息的时候，生成一个全局唯一id，放在我们消息中。
消费者获取到我们该消息，可以根据该全局唯一id实现去重复。
全局唯一id 根据业务来定的 订单号码作为全局的id
实际上还是需要再db层面解决数据防重复。
业务逻辑是在做insert操作 使用唯一主键约束
业务逻辑是在做update操作 使用乐观锁

  1. 当消费者业务逻辑代码中，抛出异常自动实现重试 （默认是无数次重试）
  2. 应该对RabbitMQ重试次数实现限制，比如最多重试5次，每次间隔3s；重试多次还是失败的情况下，存放到死信队列或者存放到数据库表中记录后期人工补偿

如何合理选择消息重试

  1. 消费者获取消息后，调用第三方接口，但是调用第三方接口失败呢？是否需要重试 ？
  2. 消费者获取消息后，应该代码问题抛出数据异常，是否需要重试？

总结：如果消费者处理消息时，因为代码原因抛出异常是需要从新发布版本才能解决的，那么就不需要重试，重试也解决不了该问题的。存放到死信队列或者是数据库表记录、后期人工实现补偿。

Rabbitmq如何开启重试策略

spring:
  rabbitmq:
    ####连接地址
    host: 127.0.0.1
    ####端口号
    port: 5672
    ####账号
    username: guest
    ####密码
    password: guest
    ### 地址
    virtual-host: /meite_rabbitmq
    listener:
      simple:
        retry:
          ####开启消费者（程序出现异常的情况下会）进行重试
          enabled: true
          ####最大重试次数
          max-attempts: 5
          ####重试间隔次数
          initial-interval: 3000

消费者重试过程中，如何避免幂等性问题
重试的过程中，为了避免业务逻辑重复执行，建议提前全局id提前查询，如果存在的情况下，就无需再继续做该流程。
重试的次数最好有一定间隔次数，在数据库底层层面保证数据唯一性，比如加上唯一id。

3.3 SpringBoot开启消息确认机制

配置文件新增

spring:
  rabbitmq:
    ####连接地址
    host: 127.0.0.1
    ####端口号
    port: 5672
    ####账号
    username: guest
    ####密码
    password: guest
    ### 地址
    virtual-host: /meiteVirtualHosts
    listener:
      simple:
        retry:
          ####开启消费者（程序出现异常的情况下会）进行重试
          enabled: true
          ####最大重试次数
          max-attempts: 5
          ####重试间隔次数
          initial-interval: 3000
        acknowledge-mode: manual
  datasource:
    url: jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=UTF-8
    username: root
    password: root
    driver-class-name: com.mysql.jdbc.Driver

消费者ack代码

@Slf4j
@Component
@RabbitListener(queues = "fanout_order_queue")
public class FanoutOrderConsumer {

    @Autowired
    private OrderManager orderManager;
    @Autowired
    private OrderMapper orderMapper;

    @RabbitHandler
    public void process(OrderEntity orderEntity, Message message, Channel channel) throws IOException {
//        try {
        log.info(">>orderEntity:{}<<", orderEntity.toString());
        String orderId = orderEntity.getOrderId();
        if (StringUtils.isEmpty(orderId)) {
            log.error(">>orderId is null<<");
            return;
        }
        OrderEntity dbOrderEntity = orderMapper.getOrder(orderId);
        if (dbOrderEntity != null) {
            log.info(">>该订单已经被消费过，无需重复消费!<<");
            // 无需继续重试
            channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
            return;
        }
        int result = orderManager.addOrder(orderEntity);

        log.info(">>插入数据库中数据成功<<");
        if (result >= 0) {
            // 开启消息确认机制
            channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
        }
//        int i = 1 / 0;
//        } catch (Exception e) {
//            // 将失败的消息记录下来，后期采用人工补偿的形式
//        }
    }
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2145821.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

C++ | Leetcode C++题解之第415题字符串相加

C++ | Leetcode C++题解之第415题字符串相加

题目&#xff1a; 题解&#xff1a; class Solution { public:string addStrings(string num1, string num2) {int i num1.length() - 1, j num2.length() - 1, add 0;string ans "";while (i > 0 || j > 0 || add ! 0) {int x i > 0 ? num1[i] - 0 …
阅读更多...
大数据Flink（一百一十八）：Flink SQL水印操作（Watermark）

大数据Flink（一百一十八）：Flink SQL水印操作（Watermark）

文章目录 Flink SQL水印操作&#xff08;Watermark&#xff09; 一、为什么要有WaterMark 二、​​​​​​​​​​​​​​Watermark解决的问题 三、​​​​​​​​​​​​​​代码演示 Flink SQL水印操作&#xff08;Watermark&#xff09; 一、​​​​​​​为什么…
阅读更多...
【数据结构】数据结构系列学习笔记——导航篇

【数据结构】数据结构系列学习笔记——导航篇

一&#xff1a;概述 数据结构是计算机科学中的核心概念之一&#xff0c;是优化算法性能和资源利用率的关键。在软件开发和数据处理中&#xff0c;选择合适的数据结构对于算法的效率至关重要。数据结构的选择通常基于数据的使用模式&#xff0c;包括数据元素之间的关系、数据的存…
阅读更多...
日志框架的使用

日志框架的使用

一、日志概述 日志&#xff1a;用来记录程序运行过程中的信息&#xff0c;并可以进行永久存储。 开发过程中可能会出现以下需求&#xff1a; 希望系统能记住某些数据是被谁操作的&#xff0c;比如被谁删除了&#xff1f;想分析用户浏览系统的具体情况&#xff0c;以便挖掘用…
阅读更多...
【深度学习】深度学习模型的加密及解密方案及源码

【深度学习】深度学习模型的加密及解密方案及源码

本文摘要 本文主要根据自己遇到的情况，例如：对于yolo或paddle训练的模型文件，对外使用，不想要别人拿到我的模型文件随意乱用，此时就涉及到对模型文件进行加密与解密 深度学习模型的加密保护非常重要，尤其在商业应用场景下。常见的模型加密方法包括模型文件加密、加密硬件…
阅读更多...
图像分割基本知识

图像分割基本知识

计算机视觉和图像处理 Tensorflow入门深度神经网络图像分类目标检测图像分割 图像分割 一、目标分割1.1 图像分割的定义1.2 任务类型1.2.1 任务描述1.2.2 任务类型 二、语义分割2.1 FCN网络2.1.1网络结构 2.2 Unet网络 三、UNet案例3.1 数据集获取3.1.1 设置相关信息3.1.2 图像…
阅读更多...
nature communications |多层次蛋白质组分析揭示弥漫型和肠型胃癌之间的分子多样性

nature communications |多层次蛋白质组分析揭示弥漫型和肠型胃癌之间的分子多样性

文章信息 发表期刊&#xff1a;nature communications 发表日期&#xff1a;2023年2月14日 影响因子&#xff1a;14.7 研究背景 胃癌是世界上主要的癌症类型之一。弥漫型胃癌(DGC)和肠型胃癌(IGC)是胃癌(GC)的主要组织学类型&#xff0c;DGC呈分散的细胞组织&#xff0c;黏…
阅读更多...
比特币10年价格数据(2014-2024)分析(进阶2_时间序列分析)

比特币10年价格数据(2014-2024)分析(进阶2_时间序列分析)

数据入口&#xff1a;【每周挑战】比特币10年价格数据可视化和量化分析 - Heywhale.com 本数据集包含 2014 - 2024 的比特币美元价格数据&#xff0c;具体包含比特币每日的开盘价、最高价、最低价、收盘价以及成交量等关键信息。数据说明如下&#xff1a; 字段说明Date日期&a…
阅读更多...
iPhone 16系列：摄影艺术的全新演绎，探索影像新境界

iPhone 16系列：摄影艺术的全新演绎，探索影像新境界

在科技的浪潮中&#xff0c;智能手机摄影功能的进化从未停歇。 苹果公司即将推出的iPhone 16系列&#xff0c;以其卓越的相机升级和创新特性&#xff0c;再次站在了手机摄影的前沿。 从硬件到软件&#xff0c;从拍照体验到图像处理&#xff0c;iPhone 16系列都展现了其在移动…
阅读更多...
camtasia2024绿色免费安装包win+mac下载含2024最新激活密钥

camtasia2024绿色免费安装包win+mac下载含2024最新激活密钥

Hey, hey, hey&#xff01;亲爱的各位小伙伴&#xff0c;今天我要给大家带来的是Camtasia2024中文版本&#xff0c;这款软件简直是视频制作爱好者的福音啊&#xff01; camtasia2024绿色免费安装包winmac下载&#xff0c;点击链接即可保存。 先说说这个版本新加的功能吧&#…
阅读更多...
Mapsui：一个 .NET 开源的地图组件库

Mapsui：一个 .NET 开源的地图组件库

前言 今天大姚给大家分享一个.NET开源&#xff08;MIT License&#xff09;、免费、同时支持多平台框架&#xff08;MAUI、WPF、Avalonia、Uno、Blazor、WinUI、Eto、.NET Android 和 .NET iOS&#xff09;地图组件库&#xff1a;Mapsui。 项目源代码 支持的UI框架的NuGet包 创…
阅读更多...
华为OD机试 - 查字典（Python/JS/C/C++ 2024 E卷 100分）

华为OD机试 - 查字典（Python/JS/C/C++ 2024 E卷 100分）

华为OD机试 2024E卷题库疯狂收录中&#xff0c;刷题点这里 专栏导读 本专栏收录于《华为OD机试真题&#xff08;Python/JS/C/C&#xff09;》。 刷的越多&#xff0c;抽中的概率越大&#xff0c;私信哪吒&#xff0c;备注华为OD&#xff0c;加入华为OD刷题交流群&#xff0c;…
阅读更多...
【研发日记】嵌入式处理器技能解锁(六)——ARM的Cortex-M4内核

【研发日记】嵌入式处理器技能解锁(六)——ARM的Cortex-M4内核

文章目录 前言 背景介绍 指令集架构 ARM起源 ARM分类 Cortex-M4 内核框架 指令流水线 实践应用 总结 参考资料 前言 见《【研发日记】嵌入式处理器技能解锁(一)——多任务异步执行调度的三种方法》 见《【研发日记】嵌入式处理器技能解锁(二)——TI C2000 DSP的SCI(…
阅读更多...
管理依赖版本-maven工程parent项目巧配置

管理依赖版本-maven工程parent项目巧配置

本文目标&#xff1a;开发人员&#xff0c;在了解pom文件properties、dependencyManagement标签用法的条件下&#xff0c;进行依赖包版本统一维护&#xff0c;达到统一维护项目依赖jar包版本的程度。 文章目录 1 场景2 要点3 总结/练习 1 场景 maven工程多模块项目&#xff0c;…
阅读更多...
数据库基础知识---------------------------（2）

数据库基础知识---------------------------（2）

MYSQL的存储过程 就是数据库 SQL 语言层面的代码封装与重用 语法格式 delimiter 自定义结束符号 create procedure 存储名({in,out,inout} 参数名,数据类型...) begin sql 语句 end 自定义结束符 delimiter; 变量定义 局部变量 用户自定义 仅在begin / end 块中有效 当将查询…
阅读更多...
高效开发，从暗藏玄机的文件系统开始—合宙Air201资产定位模组LuatOS

高效开发，从暗藏玄机的文件系统开始—合宙Air201资产定位模组LuatOS

超低功耗、精准定位、快速量产——迷你小巧的合宙Air201&#xff0c;正给越来越多的行业客户带来高效开发体验。 4G-Cat.1模组的文件系统关乎数据传输速度、存储效率&#xff0c;以及数据安全性等等诸多因素&#xff0c;在应用开发中极为重要。 本期&#xff0c;我们来学习合…
阅读更多...
微型导轨在3D打印设备中的应用与实践

微型导轨在3D打印设备中的应用与实践

微型导轨的应用范围非常广泛&#xff0c;尤其在追求高精度、高效率及低噪音的现代打印技术中扮演着重要角色。微型导轨在3D打印机等精密设备中是常用元件&#xff0c;以提高打印质量和效率。 在打印机中&#xff0c;无论是喷墨式、激光式还是3D打印机&#xff0c;都需要精确的打…
阅读更多...
JDBC编程详细总结

JDBC编程详细总结

一、JDBC编程 JDBC编程有标准步骤(八股文) 注册驱动 将sql语句的运行环境加载到JVM 连接数据库 获得执行SQL的对象 执行SQL语句,获得结果 关流 1、 注册驱动 Class.forName("com.mysql.jdbc.Driver");//5.7版本 加载驱动 Class.forName("com.mysql.cj.jdb…
阅读更多...
为什么收录是谷歌seo的底子？

为什么收录是谷歌seo的底子？

收录是谷歌SEO的基础&#xff0c;因为它决定了网站页面能否被用户找到。只有被谷歌收录的页面&#xff0c;才有机会在搜索结果中出现。如果页面没有被收录&#xff0c;谷歌根本就不知道它的存在&#xff0c;这意味着即使内容再好、关键词再精准&#xff0c;也不会有任何排名 被…
阅读更多...
fo-dicom，第一个基于.NET Standard 2.0 开发的DICOM开源库

fo-dicom，第一个基于.NET Standard 2.0 开发的DICOM开源库

1. 简介&#xff1a; fo-dicom是一个基于C#开发的库&#xff0c;用于处理DICOM&#xff08;Digital Imaging and Communications in Medicine&#xff09;格式的数据。DICOM是一种用于医学影像和相关信息的标准格式&#xff0c;广泛应用于医学领域。fo-dicom提供了多平台支持&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023