图解Kafka架构学习笔记（三）

准备Kafka环境

这里推荐使用Docker Compose快速搭建一套本地开发环境。

以下docker-compose.yml文件用来搭建一套单节点zookeeper和单节点kafka环境，并且在8080端口提供kafka-ui管理界面。

version: '2.1'

services:
  zoo1:
    image: confluentinc/cp-zookeeper:7.3.2
    hostname: zoo1
    container_name: zoo1
    ports:
      - "2181:2181"
    environment:
      ZOOKEEPER_CLIENT_PORT: 2181
      ZOOKEEPER_SERVER_ID: 1
      ZOOKEEPER_SERVERS: zoo1:2888:3888

  kafka1:
    image: confluentinc/cp-kafka:7.3.2
    hostname: kafka1
    container_name: kafka1
    ports:
      - "9092:9092"
      - "29092:29092"
      - "9999:9999"
    environment:
      KAFKA_ADVERTISED_LISTENERS: INTERNAL://kafka1:19092,EXTERNAL://${DOCKER_HOST_IP:-127.0.0.1}:9092,DOCKER://host.docker.internal:29092
      KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: INTERNAL:PLAINTEXT,EXTERNAL:PLAINTEXT,DOCKER:PLAINTEXT
      KAFKA_INTER_BROKER_LISTENER_NAME: INTERNAL
      KAFKA_ZOOKEEPER_CONNECT: "zoo1:2181"
      KAFKA_BROKER_ID: 1
      KAFKA_LOG4J_LOGGERS: "kafka.controller=INFO,kafka.producer.async.DefaultEventHandler=INFO,state.change.logger=INFO"
      KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1
      KAFKA_TRANSACTION_STATE_LOG_REPLICATION_FACTOR: 1
      KAFKA_TRANSACTION_STATE_LOG_MIN_ISR: 1
      KAFKA_JMX_PORT: 9999
      KAFKA_JMX_HOSTNAME: ${DOCKER_HOST_IP:-127.0.0.1}
      KAFKA_AUTHORIZER_CLASS_NAME: kafka.security.authorizer.AclAuthorizer
      KAFKA_ALLOW_EVERYONE_IF_NO_ACL_FOUND: "true"
    depends_on:
      - zoo1
  kafka-ui:
    container_name: kafka-ui
    image: provectuslabs/kafka-ui:latest
    ports:
      - 8080:8080
    depends_on:
      - kafka1
    environment:
      DYNAMIC_CONFIG_ENABLED: "TRUE"

参考资料

  • https://github.com/conduktor/kafka-stack-docker-compose
  • https://github.com/provectus/kafka-ui

将上述docker-compose.yml文件在本地保存，在同一目录下执行以下命令启动容器。

docker-compose up -d

如果快速启动的话，那么可以参考docker的方式

docker run -it -p 8080:8080 -e DYNAMIC_CONFIG_ENABLED=true provectuslabs/kafka-ui

容器启动后，使用浏览器打开127.0.0.1:8080 即可看到如下kafka-ui界面。

在这里插入图片描述
点击页面右侧的“Configure new cluster”按钮，配置kafka服务连接信息。

在这里插入图片描述
填写完信息后，点击页面下方的“Submit”按钮提交即可。

在这里插入图片描述

安装kafka-go

执行以下命令下载 kafka-go依赖。

go get github.com/segmentio/kafka-go

注意：kafka-go 需要 Go 1.15或更高版本。

kafka-go使用指南

kafka-go 提供了两套与Kafka交互的API。

  • 低级别（ low-level）：基于与 Kafka 服务器的原始网络连接实现。
  • 高级别（high-level）：对于常用读写操作封装了一套更易用的API。

通常建议直接使用高级别的交互API。

Connection
Conn 类型是 kafka-go 包的核心。它代表与 Kafka broker之间的连接。基于它实现了一套与Kafka交互的低级别 API。

发送消息（生产者）

下面是连接至Kafka之后，使用Conn发送消息的代码示例。

// writeByConn 基于Conn发送消息
func writeByConn() {
	topic := "my-topic"
	partition := 0

	// 连接至Kafka集群的Leader节点
	conn, err := kafka.DialLeader(context.Background(), "tcp", "localhost:9092", topic, partition)
	if err != nil {
		log.Fatal("failed to dial leader:", err)
	}

	// 设置发送消息的超时时间
	conn.SetWriteDeadline(time.Now().Add(10 * time.Second))

	// 发送消息
	_, err = conn.WriteMessages(
		kafka.Message{Value: []byte("one!")},
		kafka.Message{Value: []byte("two!")},
		kafka.Message{Value: []byte("three!")},
	)
	if err != nil {
		log.Fatal("failed to write messages:", err)
	}

	// 关闭连接
	if err := conn.Close(); err != nil {
		log.Fatal("failed to close writer:", err)
	}
}

消费消息（消费者）

// readByConn 连接至kafka后接收消息
func readByConn() {
	// 指定要连接的topic和partition
	topic := "my-topic"
	partition := 0

	// 连接至Kafka的leader节点
	conn, err := kafka.DialLeader(context.Background(), "tcp", "localhost:9092", topic, partition)
	if err != nil {
		log.Fatal("failed to dial leader:", err)
	}

	// 设置读取超时时间
	conn.SetReadDeadline(time.Now().Add(10 * time.Second))
	// 读取一批消息，得到的batch是一系列消息的迭代器
	batch := conn.ReadBatch(10e3, 1e6) // fetch 10KB min, 1MB max

	// 遍历读取消息
	b := make([]byte, 10e3) // 10KB max per message
	for {
		n, err := batch.Read(b)
		if err != nil {
			break
		}
		fmt.Println(string(b[:n]))
	}

	// 关闭batch
	if err := batch.Close(); err != nil {
		log.Fatal("failed to close batch:", err)
	}

	// 关闭连接
	if err := conn.Close(); err != nil {
		log.Fatal("failed to close connection:", err)
	}
}

使用batch.Read更高效一些，但是需要根据消息长度选择合适的buffer（上述代码中的b），如果传入的buffer太小（消息装不下）就会返回io.ErrShortBuffer错误。

如果不考虑内存分配的效率问题，也可以按以下代码使用batch.ReadMessage读取消息。

for {
  msg, err := batch.ReadMessage()
  if err != nil {
    break
  }
  fmt.Println(string(msg.Value))
}

在这里插入图片描述

创建topic

当Kafka关闭自动创建topic的设置时，可按如下方式创建topic。

// createTopicByConn 创建topic
func createTopicByConn() {
	// 指定要创建的topic名称
	topic := "my-topic"

	// 连接至任意kafka节点
	conn, err := kafka.Dial("tcp", "localhost:9092")
	if err != nil {
		panic(err.Error())
	}
	defer conn.Close()

	// 获取当前控制节点信息
	controller, err := conn.Controller()
	if err != nil {
		panic(err.Error())
	}
	var controllerConn *kafka.Conn
	// 连接至leader节点
	controllerConn, err = kafka.Dial("tcp", net.JoinHostPort(controller.Host, strconv.Itoa(controller.Port)))
	if err != nil {
		panic(err.Error())
	}
	defer controllerConn.Close()

	topicConfigs := []kafka.TopicConfig{
		{
			Topic:             topic,
			NumPartitions:     1,
			ReplicationFactor: 1,
		},
	}

	// 创建topic
	err = controllerConn.CreateTopics(topicConfigs...)
	if err != nil {
		panic(err.Error())
	}
}

通过非leader节点连接leader节点

下面的示例代码演示了如何通过已有的非leader节点的Conn，连接至 leader节点

conn, err := kafka.Dial("tcp", "localhost:9092")
if err != nil {
    panic(err.Error())
}
defer conn.Close()
// 获取当前控制节点信息
controller, err := conn.Controller()
if err != nil {
    panic(err.Error())
}
var connLeader *kafka.Conn
connLeader, err = kafka.Dial("tcp", net.JoinHostPort(controller.Host, strconv.Itoa(controller.Port)))
if err != nil {
    panic(err.Error())
}
defer connLeader.Close()

上面的代码用于通过 Kafka 协议创建一个名为 “my-topic” 的主题(topic)。让我解释一下代码的主要部分：

  1. func createTopicByConn(): 这是一个函数定义，用于创建主题的连接。

  2. topic := "my-topic": 指定要创建的主题名称为 “my-topic”。

  3. conn, err := kafka.Dial("tcp", "localhost:9092"): 通过 kafka.Dial 方法连接到 Kafka 集群中的任意一个节点。这里使用了 tcp 协议连接本地主机的 9092 端口。如果连接失败，则会产生一个错误，并且代码会中止执行。

  4. defer conn.Close(): 在函数结束时关闭连接，确保资源被释放。

  5. controller, err := conn.Controller(): 通过连接对象获取当前控制器(controller)节点的信息。Kafka 集群有一个控制器节点，负责集群中的元数据管理和协调工作。

  6. controllerConn, err = kafka.Dial("tcp", net.JoinHostPort(controller.Host, strconv.Itoa(controller.Port))): 根据获取到的控制器节点信息，再次通过 kafka.Dial 方法连接到控制器节点。这里使用了 net.JoinHostPort 函数将主机名和端口号合并为一个字符串。如果连接失败，则会产生一个错误，并且代码会中止执行。

  7. defer controllerConn.Close(): 同样在函数结束时关闭连接，确保资源被释放。

  8. topicConfigs: 定义一个 kafka.TopicConfig 类型的切片，其中包含要创建的主题的配置信息。在这里，只有一个元素，即 “my-topic” 主题的配置。

  9. err = controllerConn.CreateTopics(topicConfigs...): 调用 controllerConn 连接对象的 CreateTopics 方法来创建主题。该方法接受一个或多个 kafka.TopicConfig 类型的参数，用于指定要创建的主题的配置。如果创建失败，则会产生一个错误，并且代码会中止执行。

  10. panic(err.Error()): 如果发生了错误，代码会使用 panic 函数中止执行，并打印出错误信息。

总体来说，这段代码的作用是连接到 Kafka 集群中的控制器节点，然后通过控制器节点创建一个名为 "my-topic" 的主题。

获取topic列表

conn, err := kafka.Dial("tcp", "localhost:9092")
if err != nil {
    panic(err.Error())
}
defer conn.Close()

partitions, err := conn.ReadPartitions()
if err != nil {
    panic(err.Error())
}

m := map[string]struct{}{}
// 遍历所有分区取topic
for _, p := range partitions {
    m[p.Topic] = struct{}{}
}
for k := range m {
    fmt.Println(k)
}

上面的代码比较简单。

Reader

Reader是由 kafka-go 包提供的另一个概念，对于从单个主题-分区（topic-partition）消费消息这种典型场景，使用它能够简化代码。Reader 还实现了自动重连和偏移量管理，并支持使用 Context 支持异步取消和超时的 API。

注意： 当进程退出时，必须在 Reader 上调用 Close() 。Kafka服务器需要一个优雅的断开连接来阻止它继续尝试向已连接的客户端发送消息。如果进程使用 SIGINT (shell 中的 Ctrl-C)或 SIGTERM (如 docker stop 或 kubernetes start)终止，那么下面给出的示例不会调用 Close()。当同一topic上有新Reader连接时，可能导致延迟(例如，新进程启动或新容器运行)。在这种场景下应使用signal.Notify处理程序在进程关闭时关闭Reader。

消费消息

下面的代码演示了如何使用Reader连接至Kafka消费消息。

// readByReader 通过Reader接收消息
func readByReader() {
	// 创建Reader
	r := kafka.NewReader(kafka.ReaderConfig{
		Brokers:   []string{"localhost:9092", "localhost:9093", "localhost:9094"},
		Topic:     "topic-A",
		Partition: 0,
		MaxBytes:  10e6, // 10MB
	})
	r.SetOffset(42) // 设置Offset

	// 接收消息
	for {
		m, err := r.ReadMessage(context.Background())
		if err != nil {
			break
		}
		fmt.Printf("message at offset %d: %s = %s\n", m.Offset, string(m.Key), string(m.Value))
	}

	// 程序退出前关闭Reader
	if err := r.Close(); err != nil {
		log.Fatal("failed to close reader:", err)
	}
}

消费者组

kafka-go支持消费者组，包括broker管理的offset。要启用消费者组，只需在ReaderConfig中指定 GroupID。

使用消费者组时，ReadMessage 会自动提交偏移量。

// 创建一个reader，指定GroupID，从 topic-A 消费消息
r := kafka.NewReader(kafka.ReaderConfig{
	Brokers:  []string{"localhost:9092", "localhost:9093", "localhost:9094"},
	GroupID:  "consumer-group-id", // 指定消费者组id
	Topic:    "topic-A",
	MaxBytes: 10e6, // 10MB
})

// 接收消息
for {
	m, err := r.ReadMessage(context.Background())
	if err != nil {
		break
	}
	fmt.Printf("message at topic/partition/offset %v/%v/%v: %s = %s\n", m.Topic, m.Partition, m.Offset, string(m.Key), string(m.Value))
}

// 程序退出前关闭Reader
if err := r.Close(); err != nil {
	log.Fatal("failed to close reader:", err)
}

在使用消费者组时会有以下限制：

  • (*Reader).SetOffset 当设置了GroupID时会返回错误
  • (*Reader).Offset 当设置了GroupID时会永远返回 -1
  • (*Reader).Lag 当设置了GroupID时会永远返回 -1
  • (*Reader).ReadLag 当设置了GroupID时会返回错误
  • (*Reader).Stats 当设置了GroupID时会返回一个-1的分区

显式提交

kafka-go 也支持显式提交。当需要显式提交时不要调用 ReadMessage，而是调用 FetchMessage获取消息，然后调用 CommitMessages 显式提交。

自动提交（Autocommit）：在调用 ReadMessage 读取消息时，会自动将消费者所消费的消息的偏移量提交到 Kafka，由 Kafka 自动管理偏移量的提交。这种方式简单方便，但是可能会带来一些问题，比如当消费者在处理消息时发生错误，消息可能已经被提交，但实际上消息并没有被成功处理，这样就可能导致数据丢失或重复处理。

显式提交（Explicit commit）：在需要提交偏移量时，调用 CommitMessages 显式地提交偏移量。这样可以在消息被成功处理后再提交偏移量，从而确保消息被正确处理。这种方式需要开发者自己管理偏移量的提交，更加灵活，但也需要更多的代码来处理。

ctx := context.Background()
for {
    // 获取消息
    m, err := r.FetchMessage(ctx)
    if err != nil {
        break
    }
    // 处理消息
    fmt.Printf("message at topic/partition/offset %v/%v/%v: %s = %s\n", m.Topic, m.Partition, m.Offset, string(m.Key), string(m.Value))
    // 显式提交
    if err := r.CommitMessages(ctx, m); err != nil {
        log.Fatal("failed to commit messages:", err)
    }
}

在消费者组中提交消息时，使用给定主题/分区的最大偏移量确定该分区的提交偏移量值的情况。具体来说，如果通过调用 FetchMessage 获取了单个分区的偏移量为 1、2 和 3 的消息，然后使用偏移量为3的消息调用 CommitMessages，那么该分区的偏移量为 1 和 2 的消息也会被提交。

这种行为的意义在于，Kafka 会将偏移量视为连续的序列。当提交一个偏移量时，Kafka 会将该偏移量之前的所有消息都视为已经被处理。因此，如果使用偏移量为3的消息调用了提交操作，那么偏移量为1和2的消息也会被提交，因为它们在偏移量3之前，已经被消费者处理了。

这种方式确保了消费者组中的所有消费者都会收到相同的消息，并且每个分区的消息都会被处理一次且仅一次，从而确保了消费者组的一致性和正确性。

管理提交间隔

默认情况下，调用CommitMessages将同步向Kafka提交偏移量。为了提高性能，可以在ReaderConfig中设置CommitInterval来定期向Kafka提交偏移。

// 创建一个reader从 topic-A 消费消息
r := kafka.NewReader(kafka.ReaderConfig{
    Brokers:        []string{"localhost:9092", "localhost:9093", "localhost:9094"},
    GroupID:        "consumer-group-id",
    Topic:          "topic-A",
    MaxBytes:       10e6, // 10MB
    CommitInterval: time.Second, // 每秒刷新一次提交给 Kafka
})

Writer

向Kafka发送消息，除了使用基于Conn的低级API，kafka-go包还提供了更高级别的 Writer 类型。大多数情况下使用Writer即可满足条件，它支持以下特性。

  • 对错误进行自动重试和重新连接。
  • 在可用分区之间可配置的消息分布。
  • 向Kafka同步或异步写入消息。
  • 使用Context的异步取消。
  • 关闭时清除挂起的消息以支持正常关闭。
  • 在发布消息之前自动创建不存在的topic。

发送消息

// 创建一个writer 向topic-A发送消息
w := &kafka.Writer{
	Addr:         kafka.TCP("localhost:9092", "localhost:9093", "localhost:9094"),
	Topic:        "topic-A",
	Balancer:     &kafka.LeastBytes{}, // 指定分区的balancer模式为最小字节分布
	RequiredAcks: kafka.RequireAll,    // ack模式
	Async:        true,                // 异步
}

err := w.WriteMessages(context.Background(),
	kafka.Message{
		Key:   []byte("Key-A"),
		Value: []byte("Hello World!"),
	},
	kafka.Message{
		Key:   []byte("Key-B"),
		Value: []byte("One!"),
	},
	kafka.Message{
		Key:   []byte("Key-C"),
		Value: []byte("Two!"),
	},
)
if err != nil {
    log.Fatal("failed to write messages:", err)
}

if err := w.Close(); err != nil {
    log.Fatal("failed to close writer:", err)
}

创建不存在的topic

如果给Writer配置了AllowAutoTopicCreation:true，那么当发送消息至某个不存在的topic时，则会自动创建topic。

w := &Writer{
    Addr:                   kafka.TCP("localhost:9092", "localhost:9093", "localhost:9094"),
    Topic:                  "topic-A",
    AllowAutoTopicCreation: true,  // 自动创建topic
}

messages := []kafka.Message{
    {
        Key:   []byte("Key-A"),
        Value: []byte("Hello World!"),
    },
    {
        Key:   []byte("Key-B"),
        Value: []byte("One!"),
    },
    {
        Key:   []byte("Key-C"),
        Value: []byte("Two!"),
    },
}

var err error
const retries = 3
// 重试3次
for i := 0; i < retries; i++ {
    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    defer cancel()
    
    err = w.WriteMessages(ctx, messages...)
    if errors.Is(err, LeaderNotAvailable) || errors.Is(err, context.DeadlineExceeded) {
        time.Sleep(time.Millisecond * 250)
        continue
    }

    if err != nil {
        log.Fatalf("unexpected error %v", err)
    }
    break
}

// 关闭Writer
if err := w.Close(); err != nil {
    log.Fatal("failed to close writer:", err)
}

写入多个topic

通常，WriterConfig.Topic用于初始化单个topic的Writer。通过去掉WriterConfig中的Topic配置，分别设置每条消息的message.topic，可以实现将消息发送至多个topic。

w := &kafka.Writer{
	Addr:     kafka.TCP("localhost:9092", "localhost:9093", "localhost:9094"),
    //
    // 注意: 当此处不设置Topic时,后续的每条消息都需要指定Topic
    //
	Balancer: &kafka.LeastBytes{},
}

err := w.WriteMessages(context.Background(),
    // 注意: 每条消息都需要指定一个 Topic, 否则就会报错
	kafka.Message{
        Topic: "topic-A",
		Key:   []byte("Key-A"),
		Value: []byte("Hello World!"),
	},
	kafka.Message{
        Topic: "topic-B",
		Key:   []byte("Key-B"),
		Value: []byte("One!"),
	},
	kafka.Message{
        Topic: "topic-C",
		Key:   []byte("Key-C"),
		Value: []byte("Two!"),
	},
)
if err != nil {
    log.Fatal("failed to write messages:", err)
}

if err := w.Close(); err != nil {
    log.Fatal("failed to close writer:", err)
}

注意：Writer中的Topic和Message中的Topic是互斥的，同一时刻有且只能设置一处。

Balancer

kafka-go实现了多种负载均衡策略。特别是当你从其他Kafka库迁移过来时，你可以按如下说明选择合适的Balancer实现。

Sarama

如果从 sarama 切换过来，并且需要/希望使用相同的算法进行消息分区，则可以使用kafka.Hash或kafka.ReferenceHash。

kafka.Hash = sarama.NewHashPartitioner
kafka.ReferenceHash = sarama.NewReferenceHashPartitioner
w := &kafka.Writer{
	Addr:     kafka.TCP("localhost:9092", "localhost:9093", "localhost:9094"),
	Topic:    "topic-A",
	Balancer: &kafka.Hash{},
}
librdkafka和confluent-kafka-go
kafka.CRC32Balancer与librdkafka默认的consistent_random策略表现一致。

w := &kafka.Writer{
	Addr:     kafka.TCP("localhost:9092", "localhost:9093", "localhost:9094"),
	Topic:    "topic-A",
	Balancer: kafka.CRC32Balancer{},
}

Logging

想要记录Reader/Writer类型的操作，可以在创建时配置日志记录器。

kafka-go中的Logger是一个接口类型。

type Logger interface {
	Printf(string, ...interface{})
}

并且提供了一个LoggerFunc类型，帮我们实现了Logger接口。

type LoggerFunc func(string, ...interface{})

func (f LoggerFunc) Printf(msg string, args ...interface{}) { f(msg, args...) }

Reader

借助kafka.LoggerFunc我们可以自定义一个Logger。

// 自定义一个Logger
func logf(msg string, a ...interface{}) {
	fmt.Printf(msg, a...)
	fmt.Println()
}

r := kafka.NewReader(kafka.ReaderConfig{
	Brokers:     []string{"localhost:9092", "localhost:9093", "localhost:9094"},
	Topic:       "q1mi-topic",
	Partition:   0,
	Logger:      kafka.LoggerFunc(logf),
	ErrorLogger: kafka.LoggerFunc(logf),
})

Writer

也可以直接使用第三方日志库，例如下面示例代码中使用了zap日志库。

w := &kafka.Writer{
	Addr:        kafka.TCP("localhost:9092"),
	Topic:       "q1mi-topic",
	Logger:      kafka.LoggerFunc(zap.NewExample().Sugar().Infof),
	ErrorLogger: kafka.LoggerFunc(zap.NewExample().Sugar().Errorf),
}

参考

https://www.liwenzhou.com/posts/Go/kafka-go/
https://juejin.cn/post/7173314677550612493
https://www.topgoer.com/%E6%95%B0%E6%8D%AE%E5%BA%93%E6%93%8D%E4%BD%9C/go%E6%93%8D%E4%BD%9Ckafka/%E6%93%8D%E4%BD%9Ckafka.html
http://www.randyfield.cn/post/2021-05-05-go-kafka/

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

【Flask】Flask数据模型关系

【Flask】Flask数据模型关系

数据模型关系 一对多 如上所示&#xff0c;一个作者关联多个文章&#xff0c;暂时认定&#xff0c;一篇文章只能有一个作者。 作者以及文章的类定义如下所示&#xff1a; class Author(db.Model):id db.Column(db.Integer, primary_keyTrue)name db.Column(db.String(128)…
阅读更多...
实现登录拦截功能

实现登录拦截功能

1.4、实现登录拦截功能 温馨小贴士&#xff1a;tomcat的运行原理 当用户发起请求时&#xff0c;会访问我们像tomcat注册的端口&#xff0c;任何程序想要运行&#xff0c;都需要有一个线程对当前端口号进行监听&#xff0c;tomcat也不例外&#xff0c;当监听线程知道用户想要和…
阅读更多...
Django之Celery篇（三）

Django之Celery篇（三）

一、任务交给Celery Django任务交给Celery的方法和普通使用Celery任务的调用基本无区别，只是将执行代码的放到到View视图中 而获取结果，往往并不能把结果和第1次请求一起响应，若想获取结果是通过第2次请求获取结果 代码如下： from django.http import HttpResponsefrom …
阅读更多...
蓝桥杯2019年第十届省赛真题-组队

蓝桥杯2019年第十届省赛真题-组队

一、题目 组队 题目描述 作为篮球队教练&#xff0c;你需要从以下名单中选出 1 号位至 5 号位各一名球员&#xff0c; 组成球队的首发阵容。每位球员担任 1 号位至 5 号位时的评分如下表所示。请你计算首发阵容 1 号位至 5 号位的评分之和最大可能是多少&#xff1f; &#xff…
阅读更多...
nodejs+vue高校社团管理小程序的设计与实现python-flask-django-php

nodejs+vue高校社团管理小程序的设计与实现python-flask-django-php

相比于以前的传统手工管理方式&#xff0c;智能化的管理方式可以大幅降低学校的运营人员成本&#xff0c;实现了高校社团管理的标准化、制度化、程序化的管理&#xff0c;有效地防止了高校社团管理的随意管理&#xff0c;提高了信息的处理速度和精确度&#xff0c;能够及时、准…
阅读更多...
【LVGL-使用GUI Guider 拖拽式设计LVGL】

【LVGL-使用GUI Guider 拖拽式设计LVGL】

LVGL-使用GUI Guider 拖拽式设计LVGL ■ SDL2-简介■ PC模拟器&#xff1a;SDL2■ 编译工具链&#xff08;MinGW CMake&#xff09;■ 一个IDE&#xff0c;SDL可以配合以下IDE使用 ■ GUI Guider-简介■ GUI Guider-下载安装■ GUI Guider-使用■ 创建工程■ 切换成中文显示■…
阅读更多...
阿里云2核4G服务器优惠价格，轻量165元1年，ECS 199元一年

阿里云2核4G服务器优惠价格，轻量165元1年，ECS 199元一年

阿里云2核4G服务器优惠价格&#xff0c;轻量165元1年&#xff0c;ECS 199元一年。2024年腾讯云服务器优惠价格表&#xff0c;一张表整理阿里云服务器最新报价&#xff0c;阿里云服务器网整理云服务器ECS和轻量应用服务器详细CPU内存、公网带宽和系统盘详细配置报价单&#xff0…
阅读更多...
Redis技术学习|实战项目记录|商户缓存

Redis技术学习|实战项目记录|商户缓存

学习资料声明 黑马程序员的Redis学习视频&#xff1a;黑马程序员Redis入门到实战教程 需要用到的知识&#xff1a;linux&#xff08;推荐韩顺平老师的教程&#xff0c;学到p30&#xff0c;创建好虚拟机和简单的几个命令就好。&#xff09;SSM。SpringBoot。 还用到了MybatisPl…
阅读更多...
SpringBoot+Mysql实现的旅游景点酒店平台系统源码+运行教程+开发文档（参考论文）【猿来入此】优秀学员作品

SpringBoot+Mysql实现的旅游景点酒店平台系统源码+运行教程+开发文档（参考论文）【猿来入此】优秀学员作品

今天发布的是由【猿来入此】的优秀学员独立做的一个基于springboot脚手架的旅游景点酒店预约管理系统&#xff0c;主要实现了 除脚手架功能以外下面是系统的功能&#xff1a; 前台普通用户&#xff1a;注册、登录、首页、景点列表&#xff08;预约&#xff09;、酒店列表&#…
阅读更多...
MySQL-4.数据类型

MySQL-4.数据类型

数据库与编程不太一样&#xff0c;它会更加的珍惜字节空间&#xff0c;需考虑所定义字段的大小和所定义字段的实际使用&#xff08;有无符号&#xff09;。 4.1 数值类型 4.1.1 整型 数据类型字节数无符号数的取值范围有符号数的取值范围TINYINT10~255-128~127SMALLINT20~655…
阅读更多...
数学建模体育建模和经济建模国防科大版

数学建模体育建模和经济建模国防科大版

目录 6.体育中的数学建模 7.经济学问题中的数学建模 7.1.实物交换模型 7.2.边际效应 7.3.最佳消费选择模型 6.体育中的数学建模 体育科学的研究中&#xff0c;也有大量的数学建模问题&#xff0c;例如&#xff1a;棒球的最佳击球点问题、滑板滑雪赛道的设计、越野自行车比…
阅读更多...
基于Google云原生工程师的kubernetes最佳实践（三）

基于Google云原生工程师的kubernetes最佳实践（三）

目录 三、集群管理 利用node affinity、taint等机制管理node 通过pod affinity/anti-affinity机制将pod分配到合适的node Node分级管理 从Qos角度将Pod分级 用namespace隔离不同的环境和用户 配置RBAC权限控制 1. 遵循最小权限原则 2. 使用 Role 和 ClusterRole 分离权…
阅读更多...
STM32使用滴答定时器实现delayms

STM32使用滴答定时器实现delayms

在STM32上使用SysTick实现jiffies&#xff08;时间戳&#xff09;并且实现delay_ms 代码实现&#xff1a; volatile uint32_t jiffies 0; // 用于记录系统运行的jiffies数 void SysTick_Handler(void) {/* 每次SysTick中断&#xff0c;jiffies增加 */jiffies; }uint32_t tick…
阅读更多...
matlab 智能电器的状态监测故障模拟

matlab 智能电器的状态监测故障模拟

1、内容简介 略 83-可以交流、咨询、答疑 2、内容说明 略 U120√2sin(2) Ii1i2 逻辑关系&#xff1a; 在0-0.1&#xff0c;正弦电给并联的电容和电阻/电感供电&#xff0c;电压的有效值为120V,通过RMS模块检查电压的变化&#xff0c;在0.1时通过斩波器把电源2端与大地连接…
阅读更多...
苹果CMS影视APP源码，二开版本带视频教程

苹果CMS影视APP源码，二开版本带视频教程

编译app教程 工具下载&#xff1a;Android Studio 官网地址&#xff1a;https://developer.android.google.cn/studio/ 环境设置&#xff1a; 设置中文&#xff1a;https://blog.csdn.net/qq_37131111/article/details/131492844 汉化包找最新的下载就行了&#xff0c;随便下载…
阅读更多...
SpringJPA 做分页条件查询

SpringJPA 做分页条件查询

前言: 相信小伙伴们的项目很多都用到SpringJPA框架的吧,对于单表的增删改查利用jpa是很方便的,但是对于条件查询并且分页 是不是很多小伙伴不经常写到. 今天我整理了一下在这里分享一下. 话不多说直接上代码: Controller: RestController public class ProductInstanceContr…
阅读更多...
idea maven配置

idea maven配置

修改maven的路径&#xff08;使用本地的Maven&#xff09;&#xff0c;以及修改settings文件的位置和本地仓库的位置。 -DarchetypeCataloginternal 配置阿里云镜像&#xff08;在setting.xml文件中配置&#xff09; <!-- 配置阿里云 --> <mirror> <id>…
阅读更多...
【PHP + 代码审计】数组排序算法

【PHP + 代码审计】数组排序算法

&#x1f36c; 博主介绍&#x1f468;‍&#x1f393; 博主介绍&#xff1a;大家好&#xff0c;我是 hacker-routing &#xff0c;很高兴认识大家~ ✨主攻领域&#xff1a;【渗透领域】【应急响应】 【Java、PHP】 【VulnHub靶场复现】【面试分析】 &#x1f389;点赞➕评论➕收…
阅读更多...
需求：实现一个类似打印的效果（文字一个字一个字的输出）

需求：实现一个类似打印的效果（文字一个字一个字的输出）

实现效果&#xff1a; 需求&#xff1a;最近接到这么一个需求&#xff0c;ai机器人回复的问题&#xff0c;后端是通过websocket每隔一段事件返回数据&#xff0c;前端拿到数据后直接渲染&#xff0c;现在需要做到一个效果&#xff0c;后端返回的结果前端需要一个一个文字的输出…
阅读更多...
STM32微控制器的中断优先级设置中，抢占优先级和子优先级如何影响中断响应？

STM32微控制器的中断优先级设置中，抢占优先级和子优先级如何影响中断响应？

在STM32微控制器中&#xff0c;中断优先级设置是一个关键的概念&#xff0c;它决定了在发生多个中断时&#xff0c;哪些中断能够优先被处理。STM32的中断优先级系统包括抢占优先级&#xff08;Preemption Priority&#xff09;和子优先级&#xff08;Subpriority&#xff09;&a…
阅读更多...
最新文章

Copyright @ 2022~2023