Kafka 生产者应用解析

目录

1、生产者消息发送流程

1.1、发送原理

2、异步发送 API

2.1、普通异步发送

2.2、带回调函数的异步发送

3、同步发送 API

4、生产者分区

4.1、分区的优势

4.2、生产者发送消息的分区策略

示例1：将数据发往指定 partition 

示例2：有 key 的情况下将数据发送到Kafka

4.3、自定义分区器

5、生产者提高吞吐量

6、数据可靠性

7、数据去重

1、幂等性

8、生产者事务

1、事务原理

2、使用事务

9、数据的有序

注：示例代码使用的语言是Python

1、生产者消息发送流程

1.1、发送原理

  • 在消息发送的过程中，涉及到了两个线程——main 线程和 Sender 线程。在 main 线程 中创建了一个双端队列 RecordAccumulator。main 线程将消息发送给 RecordAccumulator， Sender 线程不断从 RecordAccumulator 中拉取消息发送到 Kafka Broker。

参数说明：

  • batch size：只有数据积累到batch.size之后，sender才会发送数据。默认16K
  • linger.ms：如果数据迟迟未达到batch.size，sender等待linger.ms设置的时间到了之后在发送是数据。单位ms，默认值为0ms，表示没有延迟。
  • acks：
    • 0：生产者发送过来的数据不需要等待应答，异步发送。
    • 1：生产者发送过来的数据，需要等待Leader收到后应该。
    • -1（all）：生产者发送过来的数据，Leader和ISR（In-Sync Replicas）队列里面所有的节点收齐数据后应答。注：-1与all等价

2、异步发送 API

2.1、普通异步发送

示例：创建 Kafka 生产者，采用异步的方式发送到 Kafka Broker

from kafka3 import KafkaProducer

def producer(topic: str, msg: str, partition=0):
    """
    :function: 生产者，生产数据
    :param topic: 写入数据所在的topic
    :param msg: 写入的数据
    :param partition: 写入数据所在的分区
    :return:
    """
    print("开始生产数据......")
    # 初始化生产者对象，bootstrap_servers参数传入kafka集群
    # 将acks的值设为0，acks=0，此方式也是异步的方式，但是生产环境中不会这样使用，因为存在数据丢失的风险
    # producer = KafkaProducer(bootstrap_servers=["170.22.70.174:9092", "170.22.70.178:9092", "170.22.70.179:9092"], acks=0)
    producer = KafkaProducer(bootstrap_servers=["170.22.70.174:9092", "170.22.70.178:9092", "170.22.70.179:9092"])
    # 将发送消息转换成bytes类型，编码使用utf-8
    future = producer.send(topic=topic, value=bytes(msg, 'utf-8'), partition=partition)
    producer.close()

if __name__ == '__main__':
    msg = "this is profucer01"
    topic = "first"
    producer(topic, msg)

2.2、带回调函数的异步发送

  • 回调函数会在 producer 收到 ack 时调用，为异步调用，该方法有两个参数，分别是元 数据信息（RecordMetadata）和异常信息（Exception），如果 Exception 为 null，说明消息发 送成功，如果 Exception 不为 null，说明消息发送失败。
  • 注意：消息发送失败会自动重试，不需要在回调函数中手动重试。
"""
带回调函数的异步发送
回调函数会在 producer 收到 ack 时调用，为异步调用，该方法有两个参数，分别是元数据信息（RecordMetadata）和异常信息（Exception），
如果 Exception 为 null，说明消息发送成功，如果 Exception 不为 null，说明消息发送失败。
"""
from kafka3 import KafkaProducer

def producer(topic: str, msg: str, partition=0):
    """
    :function: 生产者，生产数据
    :param topic: 写入数据所在的topic
    :param msg: 写入的数据
    :param partition: 写入数据所在的分区
    :return:
    """
    print("开始生产数据......")

    # 定义发送成功的回调函数
    def on_send_success(record_metadata):
        print("消息成功发送到主题:", record_metadata.topic)
        print("分区:", record_metadata.partition)
        print("偏移量:", record_metadata.offset)

    # 定义发送失败的回调函数
    def on_send_error(excp):
        print("发送消息时出现错误:", excp)
        # 可以根据实际情况执行一些错误处理逻辑

    # 初始化生产者对象，bootstrap_servers参数传入kafka集群
    producer = KafkaProducer(bootstrap_servers=["170.22.70.174:9092", "170.22.70.178:9092", "170.22.70.179:9092"])
    # 将发送消息转换成bytes类型，编码使用utf-8
    producer.send(topic=topic, value=bytes(msg, 'utf-8'), partition=partition).add_callback(on_send_success).add_errback(on_send_error)
    producer.close()

3、同步发送 API

  • 只需在异步发送的基础上，再调用一下 get()方法即可。或者将acks的值设为all，acks="all"，此方式也是同步的方式。
from kafka3 import KafkaProducer

def producer(topic: str, msg: str, partition=0):
    """
    :function: 生产者，生产数据
    :param topic: 写入数据所在的topic
    :param msg: 写入的数据
    :param partition: 写入数据所在的分区
    :return:
    """
    print("开始生产数据......")
    # 初始化生产者对象，bootstrap_servers参数传入kafka集群
    # 将acks的值设为all，acks="all"，此方式也是同步的方式.
    # producer = KafkaProducer(bootstrap_servers=["170.22.70.174:9092", "170.22.70.178:9092", "170.22.70.179:9092"], acks="all")
    producer = KafkaProducer(bootstrap_servers=["170.22.70.174:9092", "170.22.70.178:9092", "170.22.70.179:9092"])
    # 将发送消息转换成bytes类型，编码使用utf-8
    future = producer.send(topic=topic, value=bytes(msg, 'utf-8'), partition=partition)
    # 等待 Future 返回结果,设置超时时间为10秒
    future.get(timeout=10)
    producer.close()

4、生产者分区

4.1、分区的优势

  • 1、便于合理使用存储资源，每个Partition在一个Broker上存储，可以把海量的数据按照分区切割成一 块一块数据存储在多台Broker上。合理控制分区的任务，可以实现负载均衡的效果。
  • 2、提高并行度，生产者可以以分区为单位发送数据；消费者可以以分区为单位进行消费数据。

4.2、生产者发送消息的分区策略

  • 1、如果不指定分区，会使用默认分区策略。默认分区策略如下：
    • 如果key存在的情况下，将key的hash值与topic的partition进行取余得到partition值
    • 如果key不存在的情况下，会随机选择一个分区

  • 2、如果指明了分区，那么将会把数据发送到指定分区

示例1：将数据发往指定 partition 

  • 将所有数据发往分区 0 中。

# 指定分区
def producer_01(topic: str, msg: str, partition=0):
    """
    :function: 指定分区
    :param topic: 写入数据所在的topic
    :param msg: 写入的数据
    :param partition: 写入数据所在的分区
    :return:
    """
    # 初始化生产者对象，bootstrap_servers参数传入kafka集群
    producer = KafkaProducer(bootstrap_servers=["170.22.70.174:9092", "170.22.70.178:9092", "170.22.70.179:9092"])
    # 将发送消息转换成bytes类型，编码使用utf-8
    future = producer.send(topic=topic, value=bytes(msg, 'utf-8'), partition=partition)
    try:
        # 等待消息发送完成
        sendResult = future.get(timeout=10)
        print(f"消息: {msg}\n所在的分区: {sendResult.partition}\n偏移量为: {sendResult.offset}\n")
        # 关闭生产
        producer.close()
    except KafkaError as e:
        print(f"消息: {msg} 发送失败\n失败信息为: {e}\n")


msg = "this is partition"
topic = "first"
for i in range(5):
    producer_01(topic, msg+str(i))

示例2：有 key 的情况下将数据发送到Kafka

  • 没有指明 partition 值但有 key 的情况下，将 key 的 hash 值与 topic 的 partition 数进行取 余得到 partition 值。
# 没有指明 partition 值但有 key 的情况下，将 key 的 hash 值与 topic 的 partition 数进行取余得到 partition 值。
def producer_02(topic: str, msg: str, key: str):
    """
    :function: 指定分区
    :param topic: 写入数据所在的topic
    :param msg: 写入的数据
    :param key: 发送消息的key值
    :return:
    """
    # 初始化生产者对象，bootstrap_servers参数传入kafka集群
    producer = KafkaProducer(bootstrap_servers=["170.22.70.174:9092", "170.22.70.178:9092", "170.22.70.179:9092"])
    # 将发送消息转换成bytes类型，编码使用utf-8
    future = producer.send(topic=topic, key=bytes(key, 'utf-8'), value=bytes(msg, 'utf-8'))
    try:
        # 等待消息发送完成
        sendResult = future.get(timeout=10)
        print(f"消息: {msg}\n所在的分区: {sendResult.partition}\n偏移量为: {sendResult.offset}\n")
        # 关闭生产
        producer.close()
    except KafkaError as e:
        print(f"消息: {msg} 发送失败\n失败信息为: {e}\n")

msg = "this is partition"
topic = "first"
key = "a"
for i in range(5):
    producer_02(topic, msg+str(i), key)

4.3、自定义分区器

  • 可以根据实际需要，自定义实现分区器。
  • 示例：自定义分区 发送过来的数据中如果包含 hello，就发往 0 号分区，不包含 hello，就发往 1 号分区。
# 自定义分区 发送过来的数据中如果包含 hello，就发往 0 号分区，不包含 hello，就发往 1 号分区。
def producer_03(topic: str, msg: str):
    """
    :function: 自定义分区
    :param topic: 写入数据所在的topic
    :param msg: 写入的数据
    :return:
    """
    # 自定义分区器
    def my_partitioner(msg):
        if "hello" in str(msg):
            return 0
        else:
            return 1

    # 初始化生产者对象，bootstrap_servers参数传入kafka集群
    producer = KafkaProducer(bootstrap_servers=["170.22.70.174:9092", "170.22.70.178:9092", "170.22.70.179:9092"])
    # 将发送消息转换成bytes类型，编码使用utf-8
    future = producer.send(topic=topic, value=bytes(msg, 'utf-8'), partition=my_partitioner(msg))

    try:
        # 等待消息发送完成
        sendResult = future.get(timeout=10)
        print(f"消息: {msg}\n所在的分区: {sendResult.partition}\n偏移量为: {sendResult.offset}\n")
        # 关闭生产
        producer.close()
    except KafkaError as e:
        print(f"消息: {msg} 发送失败\n失败信息为: {e}\n")

msg = "hello this is partition"
msg1 = "this is partition"

5、生产者提高吞吐量

  • 实际工作中，会根据实际的情况动态的调整生产者的吞吐量以适应实际需求，调整吞吐量主要是通过调整以下参数实现：
    • batch.size：批次大小，默认16k
    • linger.ms：等待时间，修改为5-100ms
    • compression.type：压缩snappy
    • RecordAccumulator：缓冲区大小，默认32m，修改为64m
"""
生产者提高吞吐量
    1、linger.ms：等待时间，修改为5-100ms
    2、compression.type：压缩snappy
    3、RecordAccumulator：缓冲区大小，修改为64m
"""
from kafka3 import KafkaProducer
from kafka3.errors import KafkaError


def producer(topic: str, msg: str):
    """
    :function: 生产者，生产数据
    :param topic: 写入数据所在的topic
    :param msg: 写入的数据
    :return:
    """
    # 初始化生产者对象，bootstrap_servers参数传入kafka集群
    producer = KafkaProducer(bootstrap_servers=["170.22.70.174:9092", "170.22.70.178:9092", "170.22.70.179:9092"],
                             linger_ms=5, # linger_ms设置为5ms
                             compression_type="snappy", # 设置压缩类型为snappy
                             buffer_memory=64*1024*1024 # 设置缓冲区大小为64MB
                             )
    # 将发送消息转换成bytes类型，编码使用utf-8
    future = producer.send(topic=topic, value=bytes(msg, 'utf-8'))
    try:
        # 等待消息发送完成
        sendResult = future.get(timeout=10)
        print(f"消息: {msg}\n所在的分区: {sendResult.partition}\n偏移量为: {sendResult.offset}\n")
        # 关闭生产
        producer.close()
    except KafkaError as e:
        print(f"消息: {msg} 发送失败\n失败信息为: {e}\n")

6、数据可靠性

说明：数据的可靠性保证主要是通过acks的设置来保证的，下面说明acks在不同取值下的数据可靠性情况：

  • acks=0时
    • 因为生产者发送数据后就不管了，所以当Leader或Follower发生异常时，就会发生数据丢失。
    • 实际使用很少
  • acks=1时
    • 因为生产者只需要等到Leader应答后就算完成本次发生了，但是当Leader应答完成后，还没有开始同步副本数据，Leader此时挂掉，新的Leader上线后并不会收到丢失数据，因为生产者已经认为数据发送成功了，这时就会发生数据丢失。
    • 实际使用：一般用于传输普通日志
  • acks=-1时
    • 因为生产者需要等到Leader和Follower都收到数据后才算完成本次数据传输，所以可靠性高，但是当分区副本只有1个或者ISR应答的最小副本设置为1，此时和acks=1时效果一样，存在数据丢失的风险。
    • 实际使用：对可靠性要求较高的场景中，比如涉及到金钱相关的场景

综上分析：要想使得数据完全可靠条件=ACK级别设置为1 + 分区副本数大于等于2 + ISR应答最小副本数大于等于2（min.insync.replicas  参数保证）

Python代码设置acks

# acks取值：0、1、"all"
producer = KafkaProducer(bootstrap_servers=["170.22.70.174:9092", "170.22.70.178:9092", "170.22.70.179:9092"], acks=0)

7、数据去重

  • 至少一次（At Least Once）= ACK级别设置为-1 + 分区副本大于等于2 + ISR里应答的最小副本数量大于等于2；可以保证数据不丢失，但是不能保证数据不重复。
  • 最多一次（At Most Once）= ACK级别设置为0；可以保证数据不重复，但是不能保证数据不丢失。

那么如何保证数据只存储一次呢？这就需要使用幂等性。

1、幂等性

1、幂等性：

  • 1、幂等性就是指Producer不论向Broker发送多少次重复数据，Broker端都只会持久化一条，保证了不重复。
  • 2、精确一次（Exactly Once） = 幂等性 + 至少一次（ ack=-1 + 分区副本数>=2 + ISR最小副本数量>=2） 。

2、幂等性实现原理：

  • 具有<PID, Partition, SeqNumber>相同主键的消息提交时，Broker只会持久化一条。
    • 其 中PID是Kafka每次重启都会分配一个新的；
    • Partition 表示分区号；
    • Sequence Number 每次发送消息的序列号，是单调自增的。
  • 注意：幂等性只能保证的是在单分区单会话内不重复。

3、使用幂等性

  • 开启参数 enable_idempotence 默认为 true，false 关闭。
  • 目前的 kafka3 库并不支持直接设置生产者的幂等性。在 Kafka 中启用幂等性需要使用 kafka-python 或其他支持 Kafka 协议的库。
  • 以下是使用 kafka-python 库设置生产者的幂等性的示例代码：
from kafka import KafkaProducer

# 创建 KafkaProducer 实例，开启幂等性
producer = KafkaProducer(
    bootstrap_servers="127.0.0.1:9092",
    acks="all",  # 设置 acks 参数为 "all"，要求所有副本都确认消息
    enable_idempotence=True
)

8、生产者事务

说明：开启事务必须开启幂等性。

1、事务原理

存储事务信息的特殊主题：__transaction_state_分区_Leader

  • 默认有50个分区，每个分区负责一部分事务。
  • 事务划分是根据transaction.id的hash值%50，计算出该事物属于哪个分区。
  • 该分区Leader副本所在的broker节点即为这个transaction.id对应的Transaction Coordinator节点。

注意事项：生产者在使用事务功能之前，必须先自定义一个唯一的transaction.id。有了该transaction.id，即使客户端挂掉了，它重启之后也能继续处理未完成的事务。

2、使用事务

  • 目前的 kafka3 库并不支持直接创建事务。Kafka 事务的支持需要使用 kafka-python 或其他支持 Kafka 协议的库。
  • 以下是使用 kafka-python 库创建事务的示例代码：
from kafka import KafkaProducer
from kafka.errors import KafkaError

# 创建 KafkaProducer 实例，开启事务
producer = KafkaProducer(
    bootstrap_servers="127.0.0.1:9092",
    enable_idempotence=True  # 开启幂等性
)

# 初始化事务
producer.init_transactions()

# 开始事务
producer.begin_transaction()

try:
    # 发送事务性消息
    for i in range(3):
        key = b"my_key"
        value = b"my_value_%d" % i
        producer.send("my_topic", key=key, value=value)

    # 提交事务
    producer.commit_transaction()

except KafkaError as e:
    # 回滚事务
    producer.abort_transaction()
    print(f"发送消息失败: {e}")

finally:
    # 关闭 KafkaProducer 实例
    producer.close()

9、数据的有序性

说明：数据的有序性只能保证单分区有序，分区与分区之间是无序的。

1、Kafka在1.x版本之前保证数据单分区有序，条件如下：

  • max.in.flight.requests.per.connection=1 （不需要开启幂等性）

2、Kafka在1.x版本之后保证数据单分区有序，条件如下：

  • 未开启幂等性
    • 设置：max.in.flight.requests.per.connection=1
  • 开启幂等性
    • 设置：max.in.flight.requests.per.connection 小于等于5
    • 原因：因为在Kafka1.x以后，启用幂等性，Kafka服务端会缓存生产者发来的最近5个request的元数据，所以至少可以保证最近5个request的数据都是有序的。

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

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

相关文章

大数据—数仓分层概论

大数据—数仓分层概论

数据仓库&#xff08;Data Warehouse&#xff09;是一个用于集成和存储大量数据的系统&#xff0c;旨在支持企业的决策制定过程。它是一个面向主题的、集成的、非易失的数据集合&#xff0c;用于支持管理决策制定过程。数据仓库的发展源于企业对数据分析和决策支持的需求&#…
阅读更多...
tcp服务器端与多个客户端连接

tcp服务器端与多个客户端连接

如果希望Tcp服务器端可以与多个客户端连接&#xff0c;可以这样写&#xff1a; tcpServernew QTcpServer(this);connect(tcpServer,SIGNAL(newConnection()),this,SLOT(onNewConnection())); void MainWindow::onNewConnection() {QTcpSocket *tcpSocket;//TCP通讯的Sockettcp…
阅读更多...
Linux系统安全及应用(1)

Linux系统安全及应用(1)

目录 一.账号安全控制 系统账号清理 二.密码安全控制 密码安全控制 三.命令历史限制 命令历史限制 四.限制su切换用户 1&#xff09;将信任的用户加入到wheel组中 2&#xff09;修改su的PAM认证配置文件 ​编辑五.PAM认证的构成 六.使用sudo机制提升权限…
阅读更多...
PT Application Inspector 4.5 (Linux) - 静态、动态和交互式应用程序安全测试

PT Application Inspector 4.5 (Linux) - 静态、动态和交互式应用程序安全测试

PT Application Inspector 4.5 (Linux) - 静态、动态和交互式应用程序安全测试 唯一一款提供高质量分析和便捷工具以自动确认漏洞的源代码分析器 请访问原文链接&#xff1a;PT Application Inspector 4.5 (Linux) - 静态、动态和交互式应用程序安全测试&#xff0c;查看最新…
阅读更多...
自定义一个RedisTemplate

自定义一个RedisTemplate

1.引入依赖 <dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-redis</artifactId></dependency><dependency><groupId>redis.clients</groupId><artifactId>jedis&…
阅读更多...
【09-选择合适的评估指标：Scikit-learn中的性能度量】

【09-选择合适的评估指标：Scikit-learn中的性能度量】

文章目录 前言1. 了解评估指标的重要性2. 分类问题的评估指标准确率精确率和召回率F1分数混淆矩阵ROC曲线和AUC3. 回归问题的评估指标均方误差（MSE）均方根误差（RMSE）平均绝对误差（MAE）R分数4. 如何选择评估指标5. 使用Scikit-learn选择评估指标结论前言 在机器学习中，评…
阅读更多...
跳出框架：Facebook的创新策略与社交影响

跳出框架：Facebook的创新策略与社交影响

1. 引言 在数字化时代&#xff0c;社交媒体如同一面镜子&#xff0c;反映出我们社会的多元性和变革。Facebook&#xff0c;作为这面镜子中最明亮的一个&#xff0c;不仅改变了人们的日常生活&#xff0c;更深刻地塑造了社交、文化和经济的面貌。本文将深入探讨Facebook的创新策…
阅读更多...
React真的好难用

React真的好难用

我发现React就像个宗教一样&#xff0c;网络上总有一群信徒。信徒&#xff1a;React天下第一&#xff0c;谁也不能说他不好。 网络上大佬对React的评价一般有几类&#xff1a; React跟Vue比就是手动档和自动档的区别&#xff0c;高手都开手动档。—— 就一个破打工的&#xf…
阅读更多...
Swin Transformer—— 基于Transformer的图像识别模型

Swin Transformer—— 基于Transformer的图像识别模型

概述 Swin Transformer是微软研究院于2021年在ICCV上发表的一篇论文&#xff0c;因其在多个视觉任务中的出色表现而被评为当时的最佳论文。它引入了移动窗口的概念&#xff0c;提出了一种层级式的Vision Transformer&#xff0c;将Shifted Windows&#xff08;移动窗口&#x…
阅读更多...
c++图论基础(1)

c++图论基础(1)

目录 无向图 无向图度 无向图性质 有向图 有向图度 有向图性质 图的分类&#xff1a; 稀疏图&#xff1a; 稠密图&#xff1a; 零图&#xff1a; 有向完全图&#xff1a; 无向完全图&#xff1a; 度序列&#xff1a; 图是由顶点集合(简称点集)和顶点间的边(简称边…
阅读更多...
mac上安装Tomcat

mac上安装Tomcat

1. 简介 Tomcat 是一个开源的 Java 服务器&#xff0c;它实现了 Java Servlet、JavaServer Pages&#xff08;JSP&#xff09;和Java WebSocket 技术。Tomcat 是 Apache 软件基金会的一个项目&#xff0c;是一个轻量级、高性能的 Web 容器。作为一个 Web 服务器&#xff0c;To…
阅读更多...
【Java EE】CAS原理和实现以及JUC中常见的类的使用

【Java EE】CAS原理和实现以及JUC中常见的类的使用

˃͈꒵˂͈꒱ write in front ꒰˃͈꒵˂͈꒱ ʕ̯•͡˔•̯᷅ʔ大家好&#xff0c;我是xiaoxie.希望你看完之后,有不足之处请多多谅解&#xff0c;让我们一起共同进步૮₍❀ᴗ͈ . ᴗ͈ აxiaoxieʕ̯•͡˔•̯᷅ʔ—CSDN博客 本文由xiaoxieʕ̯•͡˔•̯᷅ʔ 原创 CSDN 如…
阅读更多...
11.JAVAEE之网络原理1

11.JAVAEE之网络原理1

1.应用层(和程序员接触最密切) 应用程序 在应用层这里,很多时候, 都是程序员"自定义"应用层协议的,(当然,也是有一些现成的应用层协议)&#xff08;这里的自定义协议,其实是非常简单的~~协议 >约定,程序员在代码中规定好,数据如何进行传输) 1.根据需求, 明确要传…
阅读更多...
了解HTTP代理服务器：优势、分类及应用实践

了解HTTP代理服务器：优势、分类及应用实践

在我们日常的网络使用中&#xff0c;我们经常听到HTTP代理服务器这个术语。那么&#xff0c;HTTP代理服务器到底是什么&#xff1f;它有什么优势和分类&#xff1f;又如何应用于实践中呢&#xff1f;让我们一起来了解一下。 HTTP代理服务器是一种位于客户端和服务器之间的中间…
阅读更多...
中电金信：向“新”而行——探索融合架构的项目管理在保险行业的应用

中电金信：向“新”而行——探索融合架构的项目管理在保险行业的应用

近年来&#xff0c;险企在政策推动、市场牵引、自身发展、新技术应用日趋成熟等内外部因素的驱动下&#xff0c;积极投身到数字化转型的浪潮中。在拜访各类保险客户和合作项目的过程中&#xff0c;我们发现不少险企在数字化转型中或多或少都面临着战略如何落地、技术如何承接和…
阅读更多...
美国洛杉矶站群服务器如何提高网站排名?

美国洛杉矶站群服务器如何提高网站排名?

美国洛杉矶站群服务器怎么样?美国洛杉矶站群服务器如何提高网站排名?Rak部落小编为您整理发布美国洛杉矶站群服务器如何提高网站排名? 美国洛杉矶站群服务器可以通过以下几种方式帮助提高网站排名&#xff1a; - **提升网站性能**&#xff1a;美国站群服务器通常配备高速CPU…
阅读更多...
python-pytorch官方示例Generating Names with a Character-Level RNN的部分理解0.5.03

python-pytorch官方示例Generating Names with a Character-Level RNN的部分理解0.5.03

pytorch官方示例Generating Names with a Character-Level RNN的部分理解 模型结构功能关键技术模型输入模型输出预测实现 模型结构 功能 输入一个类别名和一个英文字符&#xff0c;就可以自动生成这个类别&#xff0c;且以英文字符开始的姓名 关键技术 将字符进行one-hot编…
阅读更多...
抖音小店怎么做？新店铺起店就做这3步，核心玩法来了

抖音小店怎么做？新店铺起店就做这3步，核心玩法来了

大家好&#xff0c;我是电商笨笨熊 做抖音小店迟迟不起店&#xff0c;店铺一直没有销量怎么办&#xff1f; 新店铺玩家前期一定都遇到过这种烦恼&#xff0c;毫无头绪不知道该从哪入手&#xff1b; 实际上&#xff0c;想要店铺快速起店&#xff0c;只需要做对三步就够了。 作…
阅读更多...
基于Rust的多线程 Web 服务器

基于Rust的多线程 Web 服务器

构建多线程 Web 服务器 在 socket 上监听 TCP 连接解析少量的 HTTP 请求创建一个合适的 HTTP 响应使用线程池改进服务器的吞吐量优雅的停机和清理注意&#xff1a;并不是最佳实践 创建项目 ~/rust ➜ cargo new helloCreated binary (application) hello package~/rust ➜ma…
阅读更多...
一 SSM 整合理解

一 SSM 整合理解

SSM整合理解 一 SSM整合什么 ​ 以spring框架为基础&#xff0c;整合springmvc&#xff0c;mybatis框架&#xff0c;以更好的开发。 ​ spring管理一切组件&#xff0c;为开发更好的解耦&#xff0c;以及提供框架的组件&#xff0c;如aop&#xff0c;tx。springmvc是表述层框…
阅读更多...
最新文章

Copyright @ 2022~2023