RabbitMQ之快速入门、上手

news2024/11/25 0:57:09

前言

学习一样新技术、新框架，最重要的是学习其思想、原理。即原理性思维。

如果是因为工作原因，需要快速上手RabbitMQ，本篇或许适合你。

核心概念

  • Connection：publisher／consumer 和 broker 之间的 TCP 连接
  • Channel： 消息通道，在客户端的每个连接里，可建立多个channel，每个channel代表一个会话任务
  • Exchange： 消息交换机，它指定消息按什么规则，路由到哪个队列
  • Queue： 消息队列载体，每个消息都会被投入到一个或多个队列
  • VHost： 虚拟主机，一个broker里可以开设多个vhost，用作不同用户的权限分离

image.png

安装

  • 修改host，添加下面数据

192.168.204.179 rabbit

  • 拉取镜像

docker pull rabbitmq:3.8.2-management

  • 启动容器
docker run -d --restart=always \
    --hostname rabbit \
    --name=rabbitmq \
    -p 5671:5617 -p 5672:5672 -p4369:4369 -p 15671:15671 -p 15672:15672 -p 25672:25672 \
    rabbitmq:3.8.2-management

5671：开启管理插件时，管理界面接口
5671、5672：AMQP
4369：守护进程
25672：

用户、Virtual Host管理

用户角色

访问管理界面：192.168.204.179:15672
默认账号密码：guest

角色列表：

  • 超级管理员(administrator)可登陆管理控制台，可查看所有的信息，并且可以对用户，策略(policy)进行操作。
  • 监控者(monitoring)可登陆管理控制台，同时可以查看rabbitmq节点的相关信息(进程数，内存使用情况，磁盘使用情况等)
  • 策略制定者(policymaker)可登陆管理控制台, 同时可以对policy进行管理。但无法查看节点的相关信息(上图红框标识的部分)。
  • 普通管理者(management)仅可登陆管理控制台，无法看到节点信息，也无法对策略进行管理。
  • 其他无法登陆管理控制台，通常就是普通的生产者和消费者。

image.png

Virtual Hosts配置

每个虚拟主机就相当于一个独立的MQ服务器，虚拟主机之间相互隔离。

  • 创建虚拟主机，主机名称一般以/开头：

image.png

  • 权限设置：

image.png

添加队列

image.png

添加交换机

  • 添加交换机

image.png

  • 绑定Queue

image.png

整合SpringBoot

		<!--amqp协议的起步依赖坐标-->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-amqp</artifactId>
		</dependency>
		<!--rabbit测试依赖坐标-->
		<dependency>
			<groupId>org.springframework.amqp</groupId>
			<artifactId>spring-rabbit-test</artifactId>
			<scope>test</scope>
		</dependency>
		<!--SpringBoot测试依赖坐标-->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>


# RabbitMQ 服务host地址
spring.rabbitmq.host=rabbit
# 端口
spring.rabbitmq.port=5672
# 虚拟主机地址
spring.rabbitmq.virtual-host=/mytest
# rabbit服务的用户名
spring.rabbitmq.username=test
# rabbit服务的密码
spring.rabbitmq.password=123456

五种工作模式

1.简单模式

image.png

  • 先添加一个Queue

image.png

  • 生产者
@RunWith(SpringRunner.class)
@SpringBootTest(classes = ProducerApplication.class)
public class MQTest {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void contextLoads() {
        /**
         * 参数1：消息队列名称
         * 参数2：消息内容
         */
        rabbitTemplate.convertAndSend("/myqueue", "hello 小兔子！");
    }

}
  • 消费者
@Component
@RabbitListener(queues = "/myqueue")
public class SimpleListener {
    @RabbitHandler
    public void simpleHandler(String msg){
        System.out.println("=====接收消息====>"+msg);
    }
}

2.工作队列模式

image.png
相比于简单模式，这个模式下会存在多个消费者。

  • 在普通模式基础上，增加订阅者即可：
@Component
@RabbitListener(queues = "/myqueue")
public class SimpleListener2 {
    @RabbitHandler
    public void simpleHandler(String msg){
        System.out.println("=====222接收消息====>"+msg);
    }
}
  • 测试：
@RunWith(SpringRunner.class)
@SpringBootTest(classes = ProducerApplication.class)
public class MQTest {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void contextLoads() {
        /**
         * 参数1：消息队列名称
         * 参数2：消息内容
         */
        for (int i = 0; i < 10000; i++) {
        rabbitTemplate.convertAndSend("/myqueue", "hello 小兔子！" + i);

        }
    }

}

交换机类型

image.png

消息将发给交换机，交换机的类型决定了它会怎么处理这个消息：

  • Direct（直连交换机）：使用消息的 Routing Key 与队列的 Binding Key 进行精确匹配，只有消息的 Routing Key 与队列的 Binding Key 完全相同时，消息才会被路由到该队列。非广播。
  • Fanout（扇形交换机）：忽略消息的 Routing Key，直接将消息发送到所有与交换机绑定的队列。广播消息。
  • Topic（主题交换机）：使用通配符匹配的方式将消息路由到多个队列。通配符由字符 “#” 和 “” 组成，其中 “#” 表示匹配零个或多个单词，“” 表示匹配一个单词。支持灵活的消息路由。
  • Headers（头交换机）：使用消息的 Headers 属性来匹配队列的 Binding Headers，从而确定消息的路由。较少使用，一般情况下使用 Direct、Fanout 或 Topic 类型的交换机就能满足大部分场景。

符号 “#” 匹配一个或多个词，符号""匹配不多不少一个词。因此“audit.#” 能够匹配到“audit.irs.corporate”，但是“audit.” 只会匹配到 “audit.irs”。

总结就是交换机负责消息转发，不进行数据存储，如果没有找到绑定的队列或匹配的队列，消息将会丢失。

3.广播模式

将同一个消息广播到订阅的多个消费者手中。

创建队列和交换机

添加队列
添加交换机
绑定队列到交换机

生产者
@RunWith(SpringRunner.class)
@SpringBootTest(classes = ProducerApplication.class)
public class MQSPTest {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void contextLoads() {
        /**
         * 参数1：消息队列名称
         * 参数2：消息内容
         */
        for (int i = 0; i < 10000; i++) {
            rabbitTemplate.convertAndSend("/fanout_exchange", null, "hello 小兔子！" + i);

        }
    }

}
消费者
@Component
@RabbitListener(queues = "/fanout_queue1")
public class SimpleListener_Fanout1 {
    @RabbitHandler
    public void simpleHandler(String msg){
        System.out.println("=====222接收消息====>"+msg);
    }
}

@Component
@RabbitListener(queues = "/fanout_queue2")
public class SimpleListener_Fanout2 {
    @RabbitHandler
    public void simpleHandler(String msg){
        System.out.println("=====3333接收消息====>"+msg);
    }
}

4.路由模式

在将队列绑定到交换机的时候，需要指定路由key；发送消息的时候也要指明路由key。
image.png

配置交换机

image.png

生产者

/**
 * 路由
 **/
@RunWith(SpringRunner.class)
@SpringBootTest(classes = ProducerApplication.class)
public class MQRoutingTest {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void contextLoads() {
        /**
         * 参数1：消息队列名称
         * 参数2：消息内容
         */
        for (int i = 0; i < 10000; i++) {
            if (i % 2 == 0) {
                rabbitTemplate.convertAndSend("/routing_exchange", "info", "hello 小兔子！" + i);

            } else {

                rabbitTemplate.convertAndSend("/routing_exchange", "err", "hello 小黑子！" + i);
            }

        }
    }

}
消费者
@Component
@RabbitListener(queues = "/routing_err1")
public class Routing_Err1 {
    @RabbitHandler
    public void simpleHandler(String msg){
        System.out.println("=====routing_err1接收消息====>"+msg);
    }
}

@Component
@RabbitListener(queues = "/routing_err2")
public class Routing_Err2 {
    @RabbitHandler
    public void simpleHandler(String msg){
        System.out.println("=====routing_err2接收消息====>"+msg);
    }
}

@Component
@RabbitListener(queues = "/routing_info1")
public class Routing_info1 {
    @RabbitHandler
    public void simpleHandler(String msg){
        System.out.println("=====routing_info1接收消息====>"+msg);
    }
}

5.主题模式（通配符）

#：匹配零个或多个。
*：匹配一个。
image.png

配置

image.png

生产者

/**
 * topc
 **/
@RunWith(SpringRunner.class)
@SpringBootTest(classes = ProducerApplication.class)
public class MQTopicTest {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void contextLoads() {
        /**
         * 参数1：消息队列名称
         * 参数2：消息内容
         */
        for (int i = 0; i < 10000; i++) {
            if (i % 2 == 0) {
                rabbitTemplate.convertAndSend("/topic_exchange", "test.info", "hello 小兔子！" + i);
            } else {

                rabbitTemplate.convertAndSend("/topic_exchange", "test.err", "hello 小黑子！" + i);
            }
            rabbitTemplate.convertAndSend("/topic_exchange", "my.test.warn", "hello 小白子！" + i);
        }
    }

}
消费者
@Component
@RabbitListener(queues = "/topic_info")
public class Topic1 {
    @RabbitHandler
    public void simpleHandler(String msg){
        System.out.println("=====topic_info接收消息====>"+msg);
    }
}

@Component
@RabbitListener(queues = "/topic_err")
public class Topic2 {
    @RabbitHandler
    public void simpleHandler(String msg){
        System.out.println("=====topic_err接收消息====>"+msg);
    }
}

@Component
@RabbitListener(queues = "/topic_warn")
public class Topic3 {
    @RabbitHandler
    public void simpleHandler(String msg){
        System.out.println("=====topic_warn接收消息====>"+msg);
    }
}

工作模式总结

  • 简单模式：一个生产者和一个消费者，无需交换机。
  • 工作队列模式：一个生产者，多个消费者（竞争消息），无需交换机。
  • 发布订阅模式：fanout类型的交换机。消费广播到每个绑定的queue中。
  • 路由模式：direct类型的交换机。消息发送到路由key精确匹配的队列中。
  • 通配符模式：topic类型的交换机。消息发送到通配符匹配的路由key的队列中。

高级特性

生产者确认

rabbitmq提供了两种方式来保证投递的可靠性：

  • confirm 确认模式：消息发到交换机，不管是否成功，都回调confirmCallback。
  • return 退回模式：投递失败会回调returnCallback。
配置
spring:
  rabbitmq:
    password: 123456
    username: test
    virtualHost: /mytest
    port: 5672
    host: rabbit
    publisherReturns: true
    publisherConfirmType: SIMPLE
案例
@Slf4j
public class RabbitConfirmCallback implements RabbitTemplate.ConfirmCallback{

    @Override
    public void confirm(CorrelationData correlationData, boolean ack, String cause) {
        if (ack) {
            log.info("消息发送到exchange成功");
        } else {
            log.info("消息发送到exchange失败");
        }
    }
}


@Slf4j
public class RabbitReturnCallback implements RabbitTemplate.ReturnsCallback {

    @Override
    public void returnedMessage(ReturnedMessage returnedMessage) {
        log.info("消息发送失败：{}", returnedMessage.getMessage());

    }
}

@Configuration
public class RabbitCallBackConfig {
    @Resource
    private RabbitTemplate rabbitTemplate;

    @PostConstruct
    public void initRabbitTemplate(){
        rabbitTemplate.setConfirmCallback(new RabbitConfirmCallback());
        rabbitTemplate.setReturnsCallback(new RabbitReturnCallback());
    }

}


@RestController
public class TestController {

    @Resource
    private RabbitTemplate rabbitTemplate;

    @GetMapping("confirmCallBack")
    public String confirmCallBack() {
        for (int i = 0; i < 10000; i++) {
            rabbitTemplate.convertAndSend("/routing_exchange", "err", "hello 小黑子！" + i);
        }
        return "ok";
    }

    @GetMapping("returnCallBack")
    public String returnCallBack() {
        for (int i = 0; i < 10000; i++) {
            // 不存在的routingkey
            rabbitTemplate.convertAndSend("/routing_exchange", "err2", "hello 小黑子！" + i);
        }
        return "ok";
    }

}

消费者确认

消费者消息确认有三种类型：

  • 无确认：none。收到生产者的消息之后，直接ACK。
  • 手动确认：manual。消费者需要显式的告诉RabbitMQ消息已经确认。手动确认更安全。
  • 自动确认：auto。客户端收到消息之后，mq自动ACK。

为什么手动确认更安全？
消费者处理消息失败时，可以重新处理消息。其它优势：1.消费者可以根据处理能力控制消费速率；2.批量确认多个信息。


import com.rabbitmq.client.Channel;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageProperties;
import org.springframework.amqp.rabbit.listener.api.ChannelAwareMessageListener;
import org.springframework.stereotype.Component;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * 自定义监听器，监听到消息之后，立即执行onMessage方法
 */
@Component
public class CustomAckConsumerListener implements ChannelAwareMessageListener {

    private static final AtomicInteger errCount = new AtomicInteger();

    /**
     * 监听到消息之后执行的方法
     *
     * @param message 消息内容
     * @param channel 消息所在频道
     */
    @Override
    public void onMessage(Message message, Channel channel) throws Exception {

        //获取消息内容
        byte[] messageBody = message.getBody();
        String msg = new String(messageBody, "UTF-8");
        System.out.println("接收到消息，执行具体业务逻辑{} 消息内容：" + msg);

        //获取投递标签
        MessageProperties messageProperties =
                message.getMessageProperties();
        long deliveryTag = messageProperties.getDeliveryTag();

        // 模拟业务错误
        if(errCount.getAndIncrement() % 2 == 0) {
            System.out.println("业务报错，重回队列");
            channel.basicNack(deliveryTag, false, true);
            return;
        }
        // 签收消息，前提条件，必须在监听器的配置中，开启手动签收模式
        // 参数1：消息投递标签
        // 数2：是否批量签收：true一次性签收所有，false，只签收当前消息
        channel.basicAck(deliveryTag, false);
        System.out.println("手动签收完成：{}");
    }
}



import cn.lsj.consumer.listener.CustomAckConsumerListener;
import org.springframework.amqp.core.AcknowledgeMode;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer;
import org.springframework.amqp.rabbit.listener.adapter.MessageListenerAdapter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class ListenerConfiguration {


    /**
     * 注入消息监听器适配器
     *
     * @param customAckConsumerListener 自定义监听器对象
     */
    @Bean
    public MessageListenerAdapter messageListenerAdapter(CustomAckConsumerListener customAckConsumerListener) {
        //创建自定义监听器适配器对象
        return new MessageListenerAdapter(customAckConsumerListener);
    }

    /**
     * 注入消息监听器容器
     *
     * @param connectionFactory      连接工厂
     * @param messageListenerAdapter 自定义的消息监听器适配器
     */
    @Bean
    public SimpleMessageListenerContainer simpleMessageListenerContainer(ConnectionFactory connectionFactory, MessageListenerAdapter messageListenerAdapter) {
        //简单的消息监听器容器对象
        SimpleMessageListenerContainer container = new SimpleMessageListenerContainer();
        //绑定消息队列
        container.setQueueNames("/routing_err3");
        //设置连接工厂对象
        container.setConnectionFactory(connectionFactory);
        //设置消息监听器适配器
        container.setMessageListener(messageListenerAdapter);
        //设置手动确认消息：NONE(不确认消息)，MANUAL(手动确认消息)，AUTO(自 动确认消息)
        container.setAcknowledgeMode(AcknowledgeMode.MANUAL);
        return container;
    }

}

消费端限流

应用场景：

  • 宕机恢复之后处理大量的积压消息导致业务系统再次崩溃。
  • 短时间大量请求来到，业务系统不支持同时处理那么多的消息。

要求：必须为手动确认消息。

package cn.lsj.consumer.config;

import cn.lsj.consumer.listener.CustomAckConsumerListener;
import org.springframework.amqp.core.AcknowledgeMode;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer;
import org.springframework.amqp.rabbit.listener.adapter.MessageListenerAdapter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class ListenerConfiguration {


    /**
     * 注入消息监听器适配器
     *
     * @param customAckConsumerListener 自定义监听器对象
     */
    @Bean
    public MessageListenerAdapter messageListenerAdapter(CustomAckConsumerListener customAckConsumerListener) {
        //创建自定义监听器适配器对象
        return new MessageListenerAdapter(customAckConsumerListener);
    }

    /**
     * 注入消息监听器容器
     *
     * @param connectionFactory      连接工厂
     * @param messageListenerAdapter 自定义的消息监听器适配器
     */
    @Bean
    public SimpleMessageListenerContainer simpleMessageListenerContainer(ConnectionFactory connectionFactory, MessageListenerAdapter messageListenerAdapter) {
        //简单的消息监听器容器对象
        SimpleMessageListenerContainer container = new SimpleMessageListenerContainer();
        //绑定消息队列
        container.setQueueNames("/routing_err3");
        //设置连接工厂对象
        container.setConnectionFactory(connectionFactory);
        //设置消息监听器适配器
        container.setMessageListener(messageListenerAdapter);
        //设置手动确认消息：NONE(不确认消息)，MANUAL(手动确认消息)，AUTO(自 动确认消息)
        container.setAcknowledgeMode(AcknowledgeMode.MANUAL);
        
        //设置消费端限流，每次拉取消息多少条，默认是250条
        container.setPrefetchCount(1);

        
        return container;
    }

}

TTL(消息存活时间)

消息过期时间到未被消费则被自动清楚。

可以针对消息设置，也可以针对队列设置。

消息过期时间
rabbitTemplate.convertAndSend("/routing_exchange", "err", "hello 小黑子！" + count.getAndIncrement(), m -> {
    // 10秒
    m.getMessageProperties().setExpiration(String.valueOf(10000L));
    return m;
});
队列过期时间

参数message-TTL ，单位毫秒，在创建队列的时候添加。
image.png

注意点
  • 消息过期的优先级高于队列；
  • 即使消息已经过期，也要等到前面的消费被消费或删除才进一步处理，所以要注意消息堆积的情况。

死信队列

是什么

当消息过期未消费；当消费者拒接消息且不放回源队列；当队列队列达到最大限度时。

以上三个场景，导致了Dead message（死消息）的产生。
image.png

如何设置死信队列

image.png

延迟队列

是什么

消息到达队列之后，不会马上被消费，而是等待一段时间之后才会被消费。

应用场景
  • 定时任务；
  • 订单超时；
  • 定时通知；
  • 消息重试\错误重试：消息放入延迟队列，过一段时间重试；
如何实现？

死信队列配合过期队列实现延迟队列。

如下图，我们不设置过期队列的消费者，让消息过期之后进入死信队列，达到延迟效果。
image.png

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

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

相关文章

亚信安慧AntDB数据并行加载工具的实现（一）

亚信安慧AntDB数据并行加载工具的实现（一）

1.概述 数据加载速度是评判数据库性能的重要指标&#xff0c;能否提高数据加载速度&#xff0c;对文件数据进行并行解析&#xff0c;直接影响数据库运维管理效率。基于此&#xff0c;AntDB分布式数据库提供了两种数据加载方式&#xff1a; 一是类似于PostgreSQL的Copy命令&am…
阅读更多...
java spring boot 自定义 aop

java spring boot 自定义 aop

以一个锁的加锁和释放为例 1、先定义注解 /*** 锁切面* author fmj*/ Retention(RetentionPolicy.RUNTIME) Target(ElementType.METHOD) public interface VersionLockAOP { }2、然后定义切面类以及切点 /*** 切面*/ Component Aspect Slf4j public class VersionLockAOPAspe…
阅读更多...
GitHub Copilot 终极详细介绍

GitHub Copilot 终极详细介绍

编写代码通常是一项乏味且耗时的任务。现代开发人员一直在寻找新的方法来提高编程的生产力、准确性和效率。 像 GitHub Copilot 这样的自动代码生成工具可以使这成为可能。 GitHub Copilot 到底是什么&#xff1f; GitHub Copilot 于 2021 年 10 月推出&#xff0c;是 GitHub 的…
阅读更多...
idea配置docker推送本地镜像到远程私有仓库

idea配置docker推送本地镜像到远程私有仓库

目录 1&#xff0c;搭建远程Docker 私有仓库 Docker registry 2&#xff0c;Windows10/11系统上安装Docker Desktop 3&#xff0c;idea 配置远程私有仓库地址 4&#xff0c;idea 配置Docker 5&#xff0c;idea在本地构建镜像 6&#xff0c;推送本地Docker镜像到远程 Dock…
阅读更多...
第3课 获取并播放音频流

第3课 获取并播放音频流

本课对应源文件下载链接&#xff1a; https://download.csdn.net/download/XiBuQiuChong/88680079 FFmpeg作为一套庞大的音视频处理开源工具&#xff0c;其源码有太多值得研究的地方。但对于大多数初学者而言&#xff0c;如何快速利用相关的API写出自己想要的东西才是迫切需要…
阅读更多...
USB -- STM32F103 USB VIDEO（视频）Camera同步传输讲解（九）

USB -- STM32F103 USB VIDEO（视频）Camera同步传输讲解（九）

目录 链接快速定位 前沿 1 描述符修改 1.1 设备描述符修改 1.2 配置描述符修改 1.3 字符串描述符修改 1.4 编译报错修改 2 增加功能函数 2.1 Camera功能模块介绍 2.2 USB复位函数修改 2.3 Speaker_Data_Setup函数修改 2.4 非零端点函数修改 2.5 JEPG数据获取 3…
阅读更多...
IDEA使用HDFS的JavaApi

IDEA使用HDFS的JavaApi

注&#xff1a;以下代码操作是利用junit在java测试文件夹中实现。 1. 准备工作 1.1 创建测试类 创建测试类&#xff0c;并定义基本变量 public class HDFSJAVAAPI {// 定义后续会用到的基本变量public final String HDFS_PATH "hdfs://hadoop00/";Configuration …
阅读更多...
骑砍战团MOD开发(27)-module_tableau_materials.py材质

骑砍战团MOD开发(27)-module_tableau_materials.py材质

一.配置材质资源 OpenBrf寻找对应材质资源. tableau配置材质资源 ("round_shield_1", 0, "sample_shield_round_1", 512, 256, 0, 0, 0, 0,[(store_script_param, ":banner_mesh", 1),(set_fixed_point_multiplier, 100),(init_position, pos1),…
阅读更多...
基于Freeswitch实现的Volte网视频通知应用

基于Freeswitch实现的Volte网视频通知应用

现在运营商的Volte网络已经很好的支持视频通话了&#xff0c;因此在原来的电话语音通知的基础上&#xff0c;可以更进一步实现视频的通知&#xff0c;让用户有更好的体验&#xff0c;本文就从技术角度&#xff0c;基于Freeswitch来实现此类应用&#xff08;本文假设读者已对Fre…
阅读更多...
【Maven】linux部署maven

【Maven】linux部署maven

简介 最近学习hyperledger-fabric超级账本&#xff08;区块链&#xff09;&#xff0c;需要使用到java和maven&#xff0c;所以重新学习了一下如何部署maven&#xff0c;这里附上参考文档。在附上官方网站的下载地址&#xff1a;https://maven.apache.org/download.cgi。首先去…
阅读更多...
刷算法-- leetcode 96. 不同的二叉搜索树

刷算法-- leetcode 96. 不同的二叉搜索树

思路 观察树的组成&#xff0c;可以发现n3时的二叉搜索树可以由&#xff0c;头节点分别为1、2、3时的所有结果组成&#xff01;定义dp[i]为由i个节点组成的二叉搜索树的个数。确定递推公式&#xff0c;dp[i] 由1为头节点组成的二叉搜索树个数由2为头组成的个数…由i为头节点组…
阅读更多...
idea远程开发环境搭建

idea远程开发环境搭建

idea远程开发环境搭建 一、安装包下载二、环境准备2.1服务器端jdk、maven安装&#xff0c;代码下载略2.2JetBrainsClients下载配置 三、远程环境配置3.1 创建项目3.2 填写服务器连接信息![在这里插入图片描述](https://img-blog.csdnimg.cn/direct/4aa09073af5e4a66a5e83e7c5d1…
阅读更多...
《异常检测——从经典算法到深度学习》25 基于深度隔离林的异常检测算法

《异常检测——从经典算法到深度学习》25 基于深度隔离林的异常检测算法

《异常检测——从经典算法到深度学习》 0 概论1 基于隔离森林的异常检测算法 2 基于LOF的异常检测算法3 基于One-Class SVM的异常检测算法4 基于高斯概率密度异常检测算法5 Opprentice——异常检测经典算法最终篇6 基于重构概率的 VAE 异常检测7 基于条件VAE异常检测8 Donut: …
阅读更多...
《论文阅读：Backdoor Attacks Against Dataset Distillation》

《论文阅读：Backdoor Attacks Against Dataset Distillation》

数据浓缩下的后门攻击 1. 摘要 数据集蒸馏已成为训练机器学习模型时提高数据效率的一项重要技术。它将大型数据集的知识封装到较小的综合数据集中。在这个较小的蒸馏数据集上训练的模型可以获得与在原始训练数据集上训练的模型相当的性能。然而&#xff0c;现有的数据集蒸馏技…
阅读更多...
儿童学python语言能做什么,孩子学python哪个机构好

儿童学python语言能做什么,孩子学python哪个机构好

大家好&#xff0c;小编为大家解答儿童学python语言能做什么的问题。很多人还不知道孩子学python哪个机构好&#xff0c;现在让我们一起来看看吧&#xff01; Source code download: 本文相关源码 我们准备了很久的Python3课程终于要来了。 为什么Python3课程花了我们这么久的时…
阅读更多...
draw.io学习笔记

draw.io学习笔记

1、链接 1.1、自动连接图形 鼠标放在图形上&#xff0c;点击出现的箭头&#xff0c;会自动出常用图形 1.2、固定连接 如果拖动其中一个图形的话&#xff0c;固定链接的形状会是曲线连过去。 方法&#xff1a;不要点击左边图形鼠标放在边框上面左边出现绿圆点鼠标左键点击图形的…
阅读更多...
【模拟电路】常见电子元器件

【模拟电路】常见电子元器件

一、常见电子元器件 二、电阻器 三、电容器 四、电感器 五、电容电感组成LRC振荡电路 六、保险丝、熔断器 七、锂电池 八、接插件 九、蜂鸣器 立创商城_一站式电子元器件采购自营商城-嘉立创电子商城 华秋商城(原"华强芯城")官网_电子元器件采购网_自营现货电子元器…
阅读更多...
Python之自然语言处理库snowNLP

Python之自然语言处理库snowNLP

一、介绍 SnowNLP是一个python写的类库&#xff0c;可以方便的处理中文文本内容&#xff0c;是受到了TextBlob的启发而写的&#xff0c;由于现在大部分的自然语言处理库基本都是针对英文的&#xff0c;于是写了一个方便处理中文的类库&#xff0c;并且和TextBlob不同的是&…
阅读更多...
【Azure 架构师学习笔记】- Azure Databricks (4) - 使用Azure Key Vault 管理ADB Secret

【Azure 架构师学习笔记】- Azure Databricks (4) - 使用Azure Key Vault 管理ADB Secret

本文属于【Azure 架构师学习笔记】系列。 本文属于【Azure Databricks】系列。 接上文 【Azure 架构师学习笔记】- Azure Databricks (3) - 再次认识DataBricks 前言 Azure Databricks有access token&#xff0c;是具有ADB内部最高权限的token。在云环境中这些高级别权限的sec…
阅读更多...
Javaweb小案例-基于SpringBoot+Vue实现的Timo商城

Javaweb小案例-基于SpringBoot+Vue实现的Timo商城

前言 Timo商城是基于Springbootvue的web商城系统&#xff0c;包含了商城的后台管理系统手机端微信小程序端 底层采用web-flash作为底层基础框架搭建 基本功能包含一下模块基础模块 部门管理用户管理角色管理菜单管理权限分配参数管理数据字典管理定时任务管理操作日志登录日志…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023