Kafka事务是怎么实现的？Kafka事务消息原理详解（文末送书）

news2024/9/24 7:22:37

在这里插入图片描述

目录

    • 一、Kafka事务性消息
      • 1.1 介绍Kafka事务性消息
      • 1.2 事务性消息的应用场景
      • 1.3 Kafka事务性消息的优势
    • 二、Kafka事务性消息的使用
      • 2.1 配置Kafka以支持事务性消息
        • 生产者配置
        • 消费者配置
      • 2.2 生产者：发送事务性消息
        • 创建Kafka生产者
        • 开始事务
        • 发送消息
        • 提交或中止事务
      • 2.3 消费者：处理事务性消息
        • 创建 Kafka 消费者
        • 订阅主题
        • 处理消息
        • 提交位移
    • 三、事务性消息的最佳实践
      • 3.1 保障消息的一次交付
        • 3.1.1 生产者幂等性
        • 3.1.2 消费者去重
      • 3.2 事务性消息的监控和故障排查
        • 3.2.1 监控工具
        • 3.2.2 故障排查
      • 3.3 事务性消息的性能考量
        • 3.3.1 性能调整
        • 3.3.2 吞吐量优化
    • 四、示例：生产和消费Kafka事务性消息
      • 4.1 示例1：生产事务性消息
        • 示例1代码：生产者
        • 代码说明:
      • 4.2 示例2：消费事务性消息
        • 示例2代码：消费者
        • 代码说明:
    • 五、总结
    • 六、Spring Boot 3核心技术与最佳实践
      • 1、内容介绍
      • 2、作者简介
      • 3、参与方式

大家好，我是哪吒。

前两天，有个朋友去面试，被问到Kafka事务的问题。

她的第一反应是：

我是来面试Java的，怎么问我大数据的Kafka？

文末送5本《Spring Boot 3核心技术与最佳实践》

在这里插入图片描述

不过Kafka确实是Java程序员必备的中间件技术了，这点是毋庸置疑的。

在这里插入图片描述

Kafka几乎是当今时代背景下数据管道的首选，无论你是做后端开发、还是大数据开发，对它可能都不陌生。开源软件Kafka的应用越来越广泛。

面对Kafka的普及和学习热潮，哪吒想分享一下自己多年的开发经验，带领读者比较轻松地掌握Kafka的相关知识

上一节我们说到了解密Kafka主题的分区策略：提升实时数据处理的关键，今天系统的说一下Kafka的事务，实现步步为营，逐个击破，拿下Kafka。

在当今大数据时代，数据的可靠性和一致性变得至关重要。Kafka作为一个分布式流数据平台，强调了实时数据的高吞吐量传输，而Kafka事务性消息则在这个过程中发挥了至关重要的作用。

本文将详细介绍Kafka事务性消息，探究它们如何确保数据一致性，以及在各种应用场景中的应用。

一、Kafka事务性消息

1.1 介绍Kafka事务性消息

Kafka事务性消息是一项关键的功能，为确保数据一致性提供了重要的支持。在本部分，我们将深入了解Kafka事务性消息的基本概念。

Kafka事务性消息的概念

在这里插入图片描述

Kafka事务性消息是一种机制，用于确保消息的可靠性传递和处理。与非事务性消息相比，它们在数据处理中提供了额外的保证。一旦消息被写入Kafka集群，它们将被认为是已经处理，无论发生了什么。

为什么需要事务性消息？

在这里插入图片描述

事务性消息对于确保数据一致性至关重要。在某些应用程序中，消息的完整性和可靠性至关重要。如果在消息处理期间发生故障，如何保证消息不会丢失或重复是一个复杂的问题。Kafka事务性消息提供了解决这些问题的方式，使得消息处理更加可控和可靠。

事务性消息的特性

Kafka事务性消息具有以下关键特性：

在这里插入图片描述

  • 原子性：事务性消息要么完全成功，要么完全失败。这确保了消息不会被部分处理。

  • 可靠性：一旦消息被写入Kafka，它们将被视为已经处理，即使发生了应用程序或系统故障。

  • 顺序性：事务性消息在单个分区内保持顺序。这对于需要按顺序处理的应用程序至关重要。

  • 幂等性：Kafka生产者可以配置为幂等，确保相同的消息不会被重复发送。

  • Exactly Once语义：事务性消息支持"仅一次"语义，即消息要么完全到达一次，要么不到达。

本节的目标是帮助您理解Kafka事务性消息的核心概念。接下来，我们将探讨它们的应用场景以及相对于非事务性消息的优势。

1.2 事务性消息的应用场景

事务性消息在多种应用场景中发挥着关键作用。以下是一些常见的应用场景，其中事务性消息特别有用：

金融交易处理：在金融领域，每笔交易都必须具备原子性，确保不发生不一致或重复的交易。事务性消息可用于记录和处理金融交易，保证交易的完整性。

订单处理：在电子商务平台上，订单处理必须是可靠的，以确保订单的创建、支付和发货不会出现问题。事务性消息可用于跟踪和处理订单的不同阶段，从而确保订单流程的一致性。

库存管理：对于企业，库存管理是至关重要的。事务性消息可用于跟踪库存的变化，以确保库存的准确性和可靠性。

日志记录：在大数据和日志记录应用中，日志的完整性是至关重要的。事务性消息可用于确保日志的完整性，即使在日志处理集群发生故障时也能保持一致性。

系统通知：对于需要向用户发送通知或提醒的应用程序，确保通知的可靠发送至关重要。事务性消息可用于实现这一目标。

1.3 Kafka事务性消息的优势

相对于非事务性消息，Kafka事务性消息具有明显的优势，特别是在需要数据一致性的应用场景中。以下是Kafka事务性消息的优势：

数据一致性：事务性消息可确保消息要么被完全处理，要么不被处理。这消除了数据处理中的不一致性，有助于维护数据一致性。

可靠性：一旦消息被写入Kafka，它们将被视为已经处理，即使发生了应用程序或系统故障。这确保了消息的可靠传递。

幂等性：Kafka生产者可以配置为幂等，这意味着相同的消息不会被重复发送。这有助于减少不必要的消息传递，避免数据重复。

Exactly Once语义：事务性消息支持"仅一次"语义，即消息要么完全到达一次，要么不到达。这是某些应用程序所需的高级语义。

错误处理：事务性消息提供了一种处理错误的机制，以确保消息可以被恢复或重试，而不会丢失。

在这里插入图片描述

二、Kafka事务性消息的使用

在这一部分，我们将深入研究如何使用Kafka事务性消息来确保数据的一致性。

2.1 配置Kafka以支持事务性消息

配置Kafka以支持事务性消息对于确保消息在传递和处理过程中的一致性非常重要。在本节中，我们将详细讨论如何配置Kafka以支持事务性消息，包括生产者和消费者的设置。

生产者配置

在生产者端，需要进行一些特定的配置以启用事务性消息。以下是一些关键的配置参数：

  • acks：这是有关生产者接收到确认之后才认为消息发送成功的设置。对于事务性消息，通常将其设置为acks=all，以确保消息仅在事务完全提交后才被视为成功发送。

  • transactional.id：这是用于标识生产者实例的唯一ID。在配置文件中设置transactional.id是启用事务性消息的关键步骤。

  • enable.idempotence：幂等性是指相同的消息不会被重复发送。对于事务性消息，通常将其设置为enable.idempotence=true，以确保消息不会重复发送。

配置示例：

acks=all
transactional.id=my-transactional-id
enable.idempotence=true
消费者配置

在消费者端，同样需要进行适当的配置以确保正确处理事务性消息。以下是一些消费者的重要配置参数：

  • isolation.level：这是用于控制消费者的隔离级别的设置。对于事务性消息，通常将其设置为isolation.level=read_committed，以确保只读取已经提交的事务消息。

  • auto.offset.reset：这是消费者启动时从哪里开始读取消息的设置。通常将其设置为auto.offset.reset=earliest，以确保不会错过任何已提交的消息。

配置示例：

isolation.level=read_committed
auto.offset.reset=earliest

配置Kafka以支持事务性消息是确保消息可靠传递和处理的关键步骤。这些配置设置可以确保在生产和消费事务性消息时的正确行为。

2.2 生产者：发送事务性消息

在这一部分，我们将深入研究如何使用Kafka生产者来发送事务性消息。发送事务性消息是确保数据一致性的关键步骤，需要特别小心。以下是详细的步骤和示例：

创建Kafka生产者

首先，我们需要创建一个 Kafka 生产者的实例。这个生产者实例将负责将消息发送到 Kafka 主题。创建生产者需要配置参数，包括 Kafka 集群的地址、消息的键和值的序列化器、事务ID 等。

下面是一个创建 Kafka 生产者的示例：

import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.Producer;
import org.apache.kafka.clients.producer.ProducerConfig;
import java.util.Properties;

public class MyKafkaProducer {
    public static Producer<String, String> createProducer() {
        Properties properties = new Properties();
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");
        properties.put(ProducerConfig.TRANSACTIONAL_ID_CONFIG, "my-transactional-id");

        return new KafkaProducer<>(properties);
    }
}
开始事务

在准备发送事务性消息之前，我们需要明确地开始一个事务。这通过调用 beginTransaction 方法来实现。一旦事务开始，所有后续的消息发送将包含在这个事务中。

producer.beginTransaction();
发送消息

在事务内，我们可以开始发送消息。这些消息将被包含在事务中，只有在事务成功提交时才会真正写入 Kafka 主题。

producer.send(new ProducerRecord<>("my-topic", "key1", "value1"));
producer.send(new ProducerRecord<>("my-topic", "key2", "value2"));
提交或中止事务

事务性消息的一个关键特性是它们要么完全成功，要么完全失败。因此，在消息发送后，我们需要根据消息的处理结果来决定是提交事务还是中止事务。这可以通过调用 commitTransaction 或 abortTransaction 方法来实现。

try {
    producer.commitTransaction();
} catch (ProducerFencedException | OutOfOrderSequenceException | AuthorizationException e) {
    // 处理异常，通常中止事务并重试
    producer.close();
} catch (CommitFailedException e) {
    // 事务提交失败，通常中止事务并重试
    producer.close();
}

上述步骤提供了一个基本的示例，演示如何使用 Kafka 生产者发送事务性消息。事务性消息的发送确保了消息的可靠性和一致性，尤其在需要原子性保证的情况下非常有用。

2.3 消费者：处理事务性消息

在这一部分，我们将深入研究如何使用 Kafka 消费者来处理事务性消息。正确处理事务性消息对于保证数据一致性至关重要。以下是详细的步骤和示例：

创建 Kafka 消费者

首先，我们需要创建一个 Kafka 消费者的实例。这个消费者实例将负责从 Kafka 主题中读取消息。创建消费者需要配置参数，包括 Kafka 集群的地址、消息的键和值的反序列化器、消费者组 ID 等。

下面是一个创建 Kafka 消费者的示例：

import org.apache.kafka.clients.consumer.Consumer;
import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.KafkaConsumer;
import java.time.Duration;
import java.util.Collections;
import java.util.Properties;

public class MyKafkaConsumer {
    public static Consumer<String, String> createConsumer() {
        Properties properties = new Properties();
        properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
        properties.put(ConsumerConfig.GROUP_ID_CONFIG, "my-consumer-group");
        properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");
        properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");

        return new KafkaConsumer<>(properties);
    }
}
订阅主题

消费者需要明确地订阅包含事务性消息的主题。这通过调用 subscribe 方法来实现。一旦订阅，消费者将开始接收该主题上的消息。

consumer.subscribe(Collections.singletonList("my-topic"));
处理消息

一旦事务性消息到达，消费者需要确保消息被正确处理。这通常涉及到处理消息的逻辑，确保数据的一致性。处理消息的逻辑将根据具体的应用和需求而异。

ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(100));
for (ConsumerRecord<String, String> record : records) {
    String key = record.key();
    String value = record.value();
    // 处理消息的逻辑
}
提交位移

消费者需要负责提交消息的位移，以便正确跟踪已处理的消息。这通过调用 commitSync 或 commitAsync 方法来实现。位移的提交确保了消息不会被重复处理。

consumer.commitSync();

上述步骤提供了一个基本的示例，演示了如何使用 Kafka 消费者处理事务性消息。消费者的正确配置和消息处理确保了消息的可靠性和一致性。在实际应用中，处理消息的逻辑将更加复杂，以满足特定的需求。

在这里插入图片描述

三、事务性消息的最佳实践

在这一节，我们将提供一些关于如何使用Kafka事务性消息的最佳实践。这包括如何确保消息的一次交付、监控和故障排查以及性能优化。

3.1 保障消息的一次交付

3.1.1 生产者幂等性

确保生产者的幂等性是关键，以防止消息被重复发送。以下是一些关键策略和实践，可用于确保生产者的幂等性：

1. 分配唯一消息ID： 为每条消息分配一个唯一的消息ID。这可以是全局唯一的，也可以是特定于主题的唯一。在发送消息之前，生产者可以检查已经发送的消息记录，以确保当前消息的ID不重复。

2. 使用幂等性API： Kafka 提供了幂等性的生产者 API。你可以在生产者配置中启用幂等性，设置 enable.idempotence=true，以确保消息在发送时不会被重复处理。

3. 实现自定义幂等性： 在一些情况下，自定义实现幂等性逻辑可能是必要的。这可以涉及到在消息处理端的数据库或存储中跟踪已处理消息的状态，以确保消息不会被重复处理。

4. 设置适当的重试机制： 如果消息发送失败，生产者应该具备适当的重试机制，以确保消息最终被成功发送。重试机制需要在生产者的配置中进行设置。

3.1.2 消费者去重

保障消息不会被重复处理同样至关重要。以下是一些策略和最佳实践，可用于实现消费者的去重：

1. 幂等性消息处理逻辑： 消费者的消息处理逻辑应该是幂等的。这意味着无论消息被处理多少次，其结果都应该是相同的。这通常需要在应用程序代码中进行实施。

2. 消息唯一标识： 为每条消息分配一个唯一的标识符，如消息ID。在处理消息前，消费者可以维护一个记录已处理消息的数据结构，以确保消息不会被重复处理。

3. 消费者去重过程： 消费者在处理消息前，可以查询已处理消息的记录，如果消息已存在于记录中，可以选择跳过处理或进行进一步处理。这可以防止消息的重复处理。

4. 消费者库支持： 一些消息队列处理库提供了内置的去重机制，你可以利用这些库来简化去重处理。

以上内容提供了详细的策略和最佳实践，以确保消息的一次交付。这是保障数据一致性的关键步骤，特别适用于事务性消息的处理。这些实践可以根据具体的应用和需求进行定制化。

3.2 事务性消息的监控和故障排查

3.2.1 监控工具

监控Kafka事务性消息是确保系统的可靠性的重要部分。以下是一些监控工具和策略：

  • Kafka内置指标：Kafka提供了一组内置指标，用于监控事务性消息的性能和状态。你可以使用这些指标来跟踪消息的处理情况。

  • 日志文件：Kafka的日志文件包含了详细的事件信息，可以用于故障排查和性能分析。定期检查日志文件，以查找潜在的问题。

  • 监控系统：使用专业的监控系统，如Prometheus和Grafana，来建立实时监控和警报。这些系统可以帮助你及时发现问题并采取措施。

3.2.2 故障排查

当事务性消息出现问题时，需要能够排查和解决这些问题。以下是一些故障排查策略：

  • 日志分析：定期分析Kafka的日志文件，查找异常和错误信息。这可以帮助你及早发现问题并采取措施。

  • 监控警报：建立监控警报，以便在出现问题时立即收到通知。这有助于快速响应问题。

  • 版本和配置管理：确保Kafka和应用程序的版本和配置得到正确管理。不同版本或配置的不一致可能导致问题。

3.3 事务性消息的性能考量

性能是任何消息系统的关键指标，特别是对于高吞吐量和低延迟的需求。以下是一些性能考量和优化策略：

3.3.1 性能调整

  • 生产者性能调整：通过调整生产者的配置参数，如batch.size、acks等，可以优化消息发送性能。

  • 消费者性能调整：消费者的性能也可以通过配置参数，如max.poll.records、fetch.min.bytes等进行调整。

3.3.2 吞吐量优化
  • 分区和并

行度**：合理地选择分区数量和消费者的并行度，以确保系统能够处理大量事务性消息。

  • 水平扩展：如果系统负载增加，考虑进行水平扩展，增加Kafka代理和消费者实例，以提高吞吐量。

  • 网络和存储优化：确保网络和存储基础设施足够快，以支持高吞吐量的消息传递。

上述最佳实践策略和性能优化建议可以帮助你更好地使用Kafka事务性消息，确保消息的可靠传递和一致性处理，同时满足性能需求。通过仔细的配置、监控和故障排查，你可以建立一个可靠和高性能的消息处理系统。

四、示例：生产和消费Kafka事务性消息

在这一节，我们将提供两个示例，详细展示如何生产和消费Kafka事务性消息。

4.1 示例1：生产事务性消息

示例1代码：生产者
import org.apache.kafka.clients.producer.*;
import java.util.Properties;

public class TransactionalProducerExample {
    public static void main(String[] args) {
        String bootstrapServers = "localhost:9092";
        String topic = "my-transactional-topic";

        Properties properties = new Properties();
        properties.put("bootstrap.servers", bootstrapServers);
        properties.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        properties.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        properties.put("acks", "all");
        properties.put("enable.idempotence", "true");
        properties.put("transactional.id", "my-transactional-id");

        Producer<String, String> producer = new KafkaProducer<>(properties);

        producer.initTransactions();

        try {
            producer.beginTransaction();
            ProducerRecord<String, String> record = new ProducerRecord<>(topic, "key", "value");
            producer.send(record);
            producer.commitTransaction();
        } catch (ProducerFencedException | OutOfOrderSequenceException | AuthorizationException e) {
            // Fenced, sequence issue, or authorization exception
            producer.close();
        } catch (KafkaException e) {
            // Handle other exceptions
            producer.close();
        }

        producer.close();
    }
}
代码说明:
  • 这个示例演示了如何创建一个Kafka生产者，配置它以支持事务性消息，并生产一条事务性消息。
  • transactional.id是一个用于标识生产者事务的唯一ID。它确保了事务性消息的一致性。
  • 在try块中，我们使用producer.beginTransaction()来启动一个事务，然后发送一条消息，最后使用producer.commitTransaction()来提交事务。
  • 如果在事务期间发生异常，我们在catch块中处理异常并关闭生产者。

4.2 示例2：消费事务性消息

示例2代码：消费者
import org.apache.kafka.clients.consumer.*;
import java.time.Duration;
import java.util.Collections;
import java.util.Properties;

public class TransactionalConsumerExample {
    public static void main(String[] args) {
        String bootstrapServers = "localhost:9092";
        String groupId = "my-consumer-group";
        String topic = "my-transactional-topic";

        Properties properties = new Properties();
        properties.put("bootstrap.servers", bootstrapServers);
        properties.put("group.id", groupId);
        properties.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        properties.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");

        Consumer<String, String> consumer = new KafkaConsumer<>(properties);
        consumer.subscribe(Collections.singletonList(topic));

        while (true) {
            ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(100));
            for (ConsumerRecord<String, String> record : records) {
                System.out.printf("Consumed record with key %s and value %s%n", record.key(), record.value());
            }
        }
    }
}
代码说明:
  • 这个示例演示了如何创建一个Kafka消费者，订阅一个主题，并消费事务性消息。
  • 消费者将持续轮询主题以获取新的消息。
  • 每当有新消息可用时，它将打印出消息的键和值。

五、总结

本文深入探讨了Kafka事务性消息的关键概念、应用场景、优势、配置、使用以及最佳实践。在总结中，让我们再次强调一些关键要点，并展望Kafka事务性消息的未来。

  • Kafka事务性消息是一种机制，用于确保消息的可靠性传递和处理。它们提供了额外的保证，确保消息要么完全成功，要么完全失败。
  • 应用场景：Kafka事务性消息在金融交易、库存管理、订单处理等需要高可靠性和数据一致性的应用中发挥关键作用。
  • 优势：事务性消息相对于非事务性消息提供了更高的数据一致性和可靠性，支持原子性、幂等性和"仅一次"语义。
  • 配置：配置Kafka以支持事务性消息包括生产者和消费者的设置，如transactional.id、enable.idempotence等。
  • 生产事务性消息：使用Kafka生产者，需要初始化事务、发送消息，然后提交或中止事务，以确保消息的一致性。
  • 消费事务性消息：使用Kafka消费者，需要订阅主题并持续轮询以获取消息，然后确保消息被正确处理。
  • 最佳实践：最佳实践包括保障消息的一次交付、监控和故障排查以及性能考量，以确保系统的稳定性和高性能。

六、Spring Boot 3核心技术与最佳实践

在这里插入图片描述

1、内容介绍

京东购买链接：Spring Boot 3核心技术与最佳实践

本书是一本针对Java开发人员的图书，旨在帮助Java开发人员掌握Spring Boot的基本使用，以及深入了解Spring Boot的应用及原理。

本书内容由浅入深、循序渐进，第1～5章介绍Spring Boot的基础知识（基础入门、配置管理、Starter、自动配置、启动过程与扩展应用、日志管理），第6～9章介绍Spring Boot的综合应用（Web、数据访问、计划任务、缓存、消息队列），第10～12章介绍Spring Boot应用的附加能力（调试、单元测试、打包、部署、监控、报警），全面覆盖了Spring Boot的核心知识要点。

本书涵盖了笔者多年的研究和实践经验，从中提炼出了核心知识要点，从Spring Boot的基本概念和基础实践入手，再通过大量的知识点分析及代码实践，详细介绍如何利用Spring Boot简化开发过程，提高开发效率。

2、作者简介

周红亮（英文名为John），具有多年编程开发和系统架构经验，在大型互联网公司担任过Java高发开发工程师、开发主管、系统架构师等职位。负责并参与过多个大型分布式系统的设计和研发、改造等，从中积累了大量的微服务系统架构经验。

3、参与方式

图书数量：本次送出 5 本《Spring Boot 3核心技术与最佳实践》 ！！！

活动时间：截止到 2023-12-18 21:00:00

🏆抽奖方式：

⭐️⭐️点击下方名片，回复1218，即可参与⭐️⭐️

🏆哪吒会在朋友圈公布中奖名单。

名单公布时间：2023-12-18 21:10:00

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

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

相关文章

MATLAB 最小二乘直线拟合方法二 （36）

MATLAB 最小二乘直线拟合方法二 （36）

MATLAB 最小二乘直线拟合方法二 （36） 一、算法介绍二、算法实现1.代码2.结果一、算法介绍 这里介绍另一种拟合直线点云的方法，更为简单方便，结果与前者一致，主要内容直接复制代码使用即可，原理简单看代码即可，下面是具体的实现和拟合结果展示 二、算法实现 1.代码 代…
阅读更多...
wappalyzer基于插件的网站开发技术解析工具

wappalyzer基于插件的网站开发技术解析工具

一、wappalyzer 解释&#xff1a;这是一款强大的工具&#xff0c;其主要能提供一种快速、可靠地检测网站所使用技术栈的方法&#xff0c;也就说说&#xff0c;服务器发来的信息都会被它剖析&#xff0c;然后分析出前端的技术栈&#xff0c;有时后端所使用的技术栈如果网页特征…
阅读更多...
华为配置策略路由（基于IP地址）示例

华为配置策略路由（基于IP地址）示例

组网需求 如图1所示&#xff0c;汇聚层Switch做三层转发设备&#xff0c;接入层设备LSW做用户网关&#xff0c;接入层LSW和汇聚层Switch之间路由可达。汇聚层Switch通过两条链路连接到两个核心路由器上&#xff0c;一条是高速链路&#xff0c;网关为10.1.20.1/24&#xff1b;另…
阅读更多...
ASF-YOLO开源 | SSFF融合+TPE编码+CPAM注意力，精度提升！

ASF-YOLO开源 | SSFF融合+TPE编码+CPAM注意力，精度提升！

目录 摘要 1 Introduction 2 Related work 2.1 Cell instance segmentation 2.2 Improved YOLO for instance segmentation 3 The proposed ASF-YOLO model 3.1 Overall architecture 3.2 Scale sequence feature fusion module 3.3 Triple feature encoding module …
阅读更多...
汇总大厂-校招/社招 Java面试题--持续补充更新中-大家别光收藏，要看起来，巩固基础，就是干呀！

汇总大厂-校招/社招 Java面试题--持续补充更新中-大家别光收藏，要看起来，巩固基础，就是干呀！

** 接上篇-汇总大厂-校招/社招 Java面试题&#xff08;补充&#xff09; ** markdown文件。持续更新中&#xff08;阿里、腾讯、网易、美团、京东、华为、快手、字节…&#xff09; 上面这篇也结合着看啊&#xff0c;通宵给整理出来的。 如需下载整套资料。关注公众号后台。…
阅读更多...
多线程------ThreadLocal详解

多线程------ThreadLocal详解

目录 1. 什么是 ThreadLocal&#xff1f; 2. 如何使用 ThreadLocal&#xff1f; 3. ThreadLocal 的作用 4. ThreadLocal 的应用场景 5. ThreadLocal 的注意事项 我的其他博客 ThreadLocal 是 Java 中一个很有用的类&#xff0c;它提供了线程局部变量的支持。线程局部变量…
阅读更多...
什么时候使用匿名类，匿名类解决了什么问题？为什么需要匿名类 ？

什么时候使用匿名类，匿名类解决了什么问题？为什么需要匿名类 ？

匿名类通常在以下场景下使用&#xff1a; 一次性使用&#xff1a; 当你需要创建一个类的实例&#xff0c;但该类只在一个地方使用&#xff0c;而不打算在其他地方重复使用时&#xff0c;可以考虑使用匿名类。 简化代码&#xff1a; 当创建一个小型的、一次性的类会让代码更简洁…
阅读更多...
Antd v5.8 modal.confirm 手动控制关闭

Antd v5.8 modal.confirm 手动控制关闭

开发中经常需要使用操作提示弹窗&#xff0c;在 Antd 中的 Modal 组件提供了 confirm 方法&#xff0c;可以快速实现操作提示弹窗。本文就来介绍一下如何使用 Modal.useModal 创建弹窗&#xff0c;并且实现手动控制弹窗的关闭逻辑。 一、代码演示 import { message, Modal } f…
阅读更多...
深入理解 Go 语言 Goroutine 的工作原理

深入理解 Go 语言 Goroutine 的工作原理

一、设计思路 1、设计描述 启动服务之时先初始化一个 Goroutine Pool 池&#xff0c;这个 Pool 维护了一个类似栈的 LIFO 队列&#xff0c;里面存放负责处理任务的 Worker然后在 client 端提交 task 到 Pool 中之后&#xff0c;在 Pool 内部&#xff0c;接收 task 之后的核心…
阅读更多...
Vue引入字节跳动图标库

Vue引入字节跳动图标库

复制下面的命令安装IconPark库&#xff1a; npm install icon-park/vue-next --save 如果你不在乎打包大小&#xff0c;可以全局注册IconPark并使用。在你的main.js中配置如下代码&#xff1a; import { createApp } from "vue";import App from "./App.vue&qu…
阅读更多...
基于SSM的OA办公系统设计与实现

基于SSM的OA办公系统设计与实现

末尾获取源码 开发语言&#xff1a;Java Java开发工具&#xff1a;JDK1.8 后端框架&#xff1a;SSM 前端&#xff1a;Vue 数据库&#xff1a;MySQL5.7和Navicat管理工具结合 服务器&#xff1a;Tomcat8.5 开发软件&#xff1a;IDEA / Eclipse 是否Maven项目&#xff1a;是 目录…
阅读更多...
计算两股不同流量的气体，通过换热器换热后，高温气体的出口温度

计算两股不同流量的气体，通过换热器换热后，高温气体的出口温度

# -*- coding: utf-8 -*- """ Created on Thu Nov 30 11:23:12 2023 计算两股不同流量的气体&#xff0c;通过换热器换热后&#xff0c;高温气体的出口温度 (煤烟二级&#xff0c;计算煤烟二级热侧出口温度) ------------------------------------------------ …
阅读更多...
云原生架构总结-读书笔记

云原生架构总结-读书笔记

云原生架构进阶实战-读书笔记 云原生概念 云原生&#xff08;Cloud Native&#xff09;概念是由Pivotal的Matt Stine在2013年首次提出的。这个概念得到了社区的不断完善&#xff0c;内容越来越丰富&#xff0c;目前已经**包括了DevOps&#xff08;Development和Operations的组…
阅读更多...
ROS2 Control分析讲解

ROS2 Control分析讲解

ROS2 Control 文章目录 前言简述组成安装 框架Controller ManagerResource ManagerControllersUser Interfaces Hardware ComponentsURDF中的硬件描述机器人运行框架 总结 前言 ros2_control是一个使用&#xff08;ROS 2&#xff09;进行机器人&#xff08;实时&#xff09;控…
阅读更多...
【亚马逊云科技】通过高性能低延迟对象存储 S3实现网站资源托管

【亚马逊云科技】通过高性能低延迟对象存储 S3实现网站资源托管

本篇文章授权活动官方亚马逊云科技文章转发、改写权&#xff0c;包括不限于在 亚马逊云科技开发者社区, 知乎&#xff0c;自媒体平台&#xff0c;第三方开发者媒体等亚马逊云科技官方渠道 文章目录 前言1 S3 介绍1.1 优点 2 使用步骤2.1 注册账户2.2 创建存储桶2.2.1 打开控制…
阅读更多...
WEB服务器介绍

WEB服务器介绍

Web服务器是指驻留于因特网上某种类型计算机的程序。当Web浏览器连到服务器上并请求文件时&#xff0c;服务器将处理该请求并将文件发送到该浏览器上&#xff0c;附带的信息会告诉浏览器如何查看该文件&#xff0c;即文WEB服务器件类型。服务器使用HTTP进行信息交流&#xff0c…
阅读更多...
springboot获取配置文件属性值

springboot获取配置文件属性值

Value&#xff1a; 作用&#xff1a;属性注入&#xff0c;需要每个值上进行书写变量名 ConfigurationProperties 指定外部属性文件。在类上添加&#xff0c;常与ConfigurationProperties 配合使用
阅读更多...
RK3568平台 OTA升级原理

RK3568平台 OTA升级原理

一.前言 在迅速变化和发展的物联网市场&#xff0c;新的产品需求不断涌现&#xff0c;因此对于智能硬件设备的更新需求就变得空前高涨&#xff0c;设备不再像传统设备一样一经出售就不再变更。为了快速响应市场需求&#xff0c;一个技术变得极为重要&#xff0c;即OTA空中下载…
阅读更多...
Python占位符%详解：格式化字符串的利器

Python占位符%详解：格式化字符串的利器

更多资料获取 &#x1f4da; 个人网站&#xff1a;ipengtao.com 在Python中&#xff0c;%占位符是一种强大的工具&#xff0c;用于格式化字符串。本文将深入解析Python中占位符的使用方法&#xff0c;包括字符串格式化、数字格式化、日期格式化等多个方面。通过丰富的示例代码…
阅读更多...
FolkMQ 国产消息中间件，v1.0.21 发布

FolkMQ 国产消息中间件，v1.0.21 发布

简介 采用 “多路复用” “内存运行” “快照持久化” “Broker 集群模式”&#xff08;可选&#xff09;基于 Socket.D 网络应用协议 开发。全新设计&#xff0c;自主架构&#xff01; 角色功能生产端发布消息&#xff08;Qos0、Qos1&#xff09;、发布定时消息&#xff…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023