电商系统设计到开发03 引入Kafka异步削峰

news2024/11/17 15:28:17

一、前言

系统设计：电商系统设计到开发01 第一版设计到编码-CSDN博客

接着上篇文章：电商系统设计到开发02 单机性能压测-CSDN博客

本篇为大制作，内容有点多，也比较干货，希望可以耐心看看

已经开发的代码，并对其下单接口进行了压力测试压力测试，该接口一个请求需要查询数据库4次，更新4次 ，插入2次，总共访问数据库10次，其中2个事务，3次查询是加锁查询，还有 1 次 rpc 请求，单实例情况下吞吐量为110/s

今天我们将其引入Kafka，看看吞吐量会有多少的提升，又会引入什么新的问题呢？

Kafka的安装流程：SpringBoot3.1.7集成Kafka和Kafka安装-CSDN博客

二、流程图

三、要求

保证消息的精准一次，不能多下单，也不能少下单

因为订单提交改成了异步创建，那么后端不会立即返回下单结果，所以一般需要前端也配合着改动，我们现在暂时不考虑前端的具体实现，但是另外一个问题就是消息要做到精准一次，不能多下订单，也不能少下订单，后面我们会进行破坏性测试，然后验证是否可以做到保证消息的精准一次

1 生产者保证消息不丢失

配置生产者的acks = all （表示要等到Kafka集群中所有的isr队列里的的broker落盘以后才返回确认）

2 kafka集群保证消息不丢失

要保证服务器不丢消息：min.insync.replicas 要设置为>1 (只要不是2台服务同时宕机就不会丢消息) Kafka 2.6.0 版本引入了针对 Topic 的 min.insync.replicas 配置，允许您为每个 Topic 单独设置 ISR 的最小副本数。在这之前，min.insync.replicas 配置是全局的，适用于所有 Topic。

3  消费者保障消息不丢失

取消自动提交offset，spring: kafka: consumer:enable:auto:commit: false ，等消息成功消费后手动提交消息的offset

4 保证消息不多发

enable.idempotence（生产者配置）可以保证消息不多发（默认是true，可以不用配置）

四、Kafka集群服务端配置

条件有限，我暂时在一台1核2G的Centos虚拟机上面配置并启动3个Kafka实例实现伪分布式集群，启动模式采用的是Kraft模式，Kafka集群端口分别为9093,9193,9293

1 复制3分Kafka实例

2 配置服务配置

kafka00/config/kraft/server.properties

kafka01/config/kraft/server.properties

kafka02/config/kraft/server.properties

3 初始化Kafka

先生成一个集群ID

KAFKA_CLUSTER_ID="$(bin/kafka-storage.sh random-uuid)"

然后分别在Kafka00、Kafka01、Kafka02的目录下执行下面初始化命令

bin/kafka-storage.sh format -t $KAFKA_CLUSTER_ID -c config/kraft/server.properties

确认一下，他们3个的集群ID是否相同

4 启动Kafka集群

编写启动脚本

nohup kafka00/bin/kafka-server-start.sh kafka00/config/kraft/server.properties >kafka00/out.log 2>&1 &
nohup kafka01/bin/kafka-server-start.sh kafka01/config/kraft/server.properties >kafka01/out.log 2>&1 &
nohup kafka02/bin/kafka-server-start.sh kafka02/config/kraft/server.properties >kafka02/out.log 2>&1 &

执行，启动成功了

5 创建一个订单topic

找到Kafka目录，输入bin/kafka-topics.sh，如果不知道如何填参数，可以先按下回车，会列举所有的参数选项，我这边创建一个topic名称为order-message-topic，分区数为2，副本为3

bin/kafka-topics.sh  --bootstrap-server localhost:9092 --create --topic order-message-topic  --partitions 2 --replication-factor 3 --config min.insync.replicas=2

创建完成，我们看一眼刚刚已创建的topic

bin/kafka-topics.sh  --bootstrap-server localhost:9092 --describe --topic order-message-topic

这里有个小插曲：

本来想安装一个Kafka的可视化界面，因为我使用的是去zookeeper化的Kraft模式启动，市面上居然还没有支持这种模式的界面，看看Kafka-manager CMAK 已经在催更了

五、应用程序开发

1 配置Kafka参数到应用程序的application.yml

spring:
  kafka:
    bootstrap-servers: 192.168.31.114:9092,192.168.31.114:9192,192.168.31.114:9292
    producer:
      acks: all
      timeout.ms: 5000
      retries: 3
      # 值序列化：使用Json
      value-serializer: org.springframework.kafka.support.serializer.JsonSerializer
      key-serializer: org.apache.kafka.common.serialization.LongSerializer
      enable:
        idempotence: true # 默认为True

# 因为消费者需要更加细粒度的控制，所以单独写配置文件
kafka-consumer:
  bootstrapServers: 192.168.31.114:9092,192.168.31.114:9192,192.168.31.114:9292
  groupId: goods-center
  #后台的心跳线程必须在30秒之内提交心跳,否则会reBalance
  sessionTimeOut: 30000
  autoOffsetReset: latest
  #取消自动提交,即便如此 spring会帮助我们自动提交
  enableAutoCommit: false
  #自动提交间隔
  autoCommitInterval: 1000
  #拉取的最小字节
  fetchMinSize: 1
  #拉去最小字节的最大等待时间
  fetchMaxWait: 500
  maxPollRecords: 100
  #300秒的提交间隔,如果程序大于300秒提交,会报错
  maxPollInterval: 300000
  #心跳间隔
  heartbeatInterval: 10000
  keyDeserializer: org.apache.kafka.common.serialization.LongDeserializer
  valueDeserializer: org.springframework.kafka.support.serializer.JsonDeserializer

2 编写生成者代码发送订单信息

kafkaTemplate.send 方法采用的是异步发送，先将消息发送到缓冲区，然后再批量打包异步发送出去，从而提高Kafka的性能，但是这样操作，可能会导致消息的丢失，然后前端认为消息已经发送出去了，解决这种方式，可以采用同步等待消息发送的结果，代码如下
package com.ychen.goodscenter.fafka;


import com.ychen.goodscenter.vo.req.SubmitOrderReq;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.kafka.support.SendResult;
import org.springframework.stereotype.Component;

import java.util.concurrent.CompletableFuture;

@Component
@Slf4j
public class MessageProducer {
    @Autowired
    private KafkaTemplate<Long, SubmitOrderReq> kafkaTemplate;

    public void sendOrderMessageSync(SubmitOrderReq msg) {
        CompletableFuture<SendResult<Long, SubmitOrderReq>> future =
                kafkaTemplate.send(TopicConstants.ORDER_MESSAGE_TOPIC, msg.getOrderId(), msg);
        try {
            // 同步等待发送结果
            SendResult<Long, SubmitOrderReq> result = future.get();
            // 处理成功发送的情况
            log.info("order-message-topic message send successfully: " + result.getRecordMetadata().toString());
        } catch (Exception e) {
            // 处理发送失败的情况
            log.info("order-message-topic message send error message: " + e.getMessage());
            throw new RuntimeException(e);
        }
    }
}

package com.ychen.goodscenter.controllers;

import com.ychen.framework.utils.Result;
import com.ychen.framework.utils.SnowFlakeUtils;
import com.ychen.goodscenter.entity.OrderInfo;
import com.ychen.goodscenter.fafka.MessageProducer;
import com.ychen.goodscenter.service.OrderService;
import com.ychen.goodscenter.vo.req.SubmitOrderReq;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;


@RestController
public class OrderController {
    @Autowired
    private MessageProducer messageProducer;

    @PostMapping("/submitOrderAsync")
    public Result submitOrderAsync(@RequestBody SubmitOrderReq req) {
        // 生成订单ID,消息幂等处理
        req.setOrderId(SnowFlakeUtils.nextId());
        messageProducer.sendOrderMessageSync(req);
        return Result.ok();
    }
}

3 编写消费者代码

为了更加细粒度的控制消费者的消费失败处理，所以单独写配置文件，并且通过自定义KafkaListenerContainerFactory的方式实现

  1. 手动提交
  2. 消息消费失败重试3次
  3. 重试3次仍然失败后会将消息保存到Kafka的死信队列
KafkaConsumerProperties
package com.ychen.goodscenter.fafka;

import lombok.Getter;
import lombok.Setter;
import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;

import java.util.HashMap;
import java.util.Map;

@Configuration
//指定配置文件的前缀
@ConfigurationProperties(prefix = "kafka-consumer")
@Getter
@Setter
public class KafkaConsumerProperties {
 
    private String groupId;
 
    private String sessionTimeOut;
 
    private String bootstrapServers;
 
    private String autoOffsetReset;
 
    private boolean enableAutoCommit;
 
    private String autoCommitInterval;
 
    private String fetchMinSize;
 
    private String fetchMaxWait;
 
    private String maxPollRecords;
 
    private String maxPollInterval;
 
    private String heartbeatInterval;
 
    private String keyDeserializer;
 
    private String valueDeserializer;

    public Map<String, Object> consumerConfigs() {
        Map<String, Object> propsMap = new HashMap<>();
        // 服务器地址
        propsMap.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, bootstrapServers);
        // 是否自动提交
        propsMap.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, enableAutoCommit);
        // 自动提交间隔
        propsMap.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG, autoCommitInterval);

        //会话时间
        propsMap.put(ConsumerConfig.SESSION_TIMEOUT_MS_CONFIG, sessionTimeOut);
        //key序列化
        propsMap.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, keyDeserializer);
        //value序列化
        propsMap.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, valueDeserializer);
        // 心跳时间
        propsMap.put(ConsumerConfig.HEARTBEAT_INTERVAL_MS_CONFIG, heartbeatInterval);

        // 分组id
        propsMap.put(ConsumerConfig.GROUP_ID_CONFIG, groupId);
        //消费策略
        propsMap.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, autoOffsetReset);
        // poll记录数
        propsMap.put(ConsumerConfig.MAX_POLL_RECORDS_CONFIG, maxPollRecords);
        //poll时间
        propsMap.put(ConsumerConfig.MAX_POLL_INTERVAL_MS_CONFIG, maxPollInterval);

        propsMap.put("spring.json.trusted.packages", "com.ychen.**");

        return propsMap;
    }

}
KafkaConsumerConfig
package com.ychen.goodscenter.fafka;

import com.alibaba.fastjson2.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.kafka.config.ConcurrentKafkaListenerContainerFactory;
import org.springframework.kafka.config.KafkaListenerContainerFactory;
import org.springframework.kafka.core.ConsumerFactory;
import org.springframework.kafka.core.DefaultKafkaConsumerFactory;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.kafka.listener.*;
import org.springframework.util.backoff.BackOff;
import org.springframework.util.backoff.FixedBackOff;

import java.util.Map;

@Configuration
@EnableConfigurationProperties(KafkaConsumerProperties.class)
@Slf4j
public class KafkaConsumerConfig {
    @Autowired
    private KafkaConsumerProperties kafkaConsumerProperties;

    @Autowired
    private KafkaTemplate<String, String> kafkaTemplate;

    @Bean
    public KafkaListenerContainerFactory<ConcurrentMessageListenerContainer<String, String>> kafkaListenerContainerFactory() {
        ConcurrentKafkaListenerContainerFactory<String, String> factory = new ConcurrentKafkaListenerContainerFactory<>();
        factory.setConsumerFactory(consumerFactory());
        // 并发数 多个微服务实例会均分
        factory.setConcurrency(2);
//        factory.setBatchListener(true);
        factory.setCommonErrorHandler(commonErrorHandler());

        ContainerProperties containerProperties = factory.getContainerProperties();
        // 是否设置手动提交
        containerProperties.setAckMode(ContainerProperties.AckMode.MANUAL_IMMEDIATE);

        return factory;
    }
    
    private ConsumerFactory<String, String> consumerFactory() {
        Map<String, Object> consumerConfigs = kafkaConsumerProperties.consumerConfigs();
        log.info("消费者的配置信息:{}", JSONObject.toJSONString(consumerConfigs));
        return new DefaultKafkaConsumerFactory<>(consumerConfigs);
    }
    
    public CommonErrorHandler commonErrorHandler() {
        // 创建 FixedBackOff 对象
        BackOff backOff = new FixedBackOff(5000L, 3L);

        DefaultErrorHandler defaultErrorHandler = new DefaultErrorHandler(new DeadLetterPublishingRecoverer(kafkaTemplate), backOff);

        return defaultErrorHandler;
    }
}
MessageListener
package com.ychen.goodscenter.fafka;

import com.ychen.goodscenter.service.OrderService;
import com.ychen.goodscenter.vo.req.SubmitOrderReq;
import lombok.extern.slf4j.Slf4j;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DuplicateKeyException;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.kafka.support.Acknowledgment;
import org.springframework.stereotype.Component;

@Component
@Slf4j
public class MessageListener {
    @Autowired
    private OrderService orderService;

    @KafkaListener(topics = TopicConstants.ORDER_MESSAGE_TOPIC, containerFactory = "kafkaListenerContainerFactory")
    public void processMessage(ConsumerRecord<Long, SubmitOrderReq> record, Acknowledgment acknowledgment) {
        log.info("order-message-topic message Listener, Thread ID: " + Thread.currentThread().getId());

        try {
            log.info("order-message-topic message received, orderId: {}", record.value().getOrderId());

            orderService.submitOrder(record.value());
            // 同步提交
            acknowledgment.acknowledge();
            log.info("order-message-topic message acked: orderId: {}", record.value().getOrderId());
        } catch (DuplicateKeyException dupe) {
            // 处理异常情况
            log.error("order-message-topic message error DuplicateKeyException", dupe);
            // 重复数据，忽略掉，同步提交
            acknowledgment.acknowledge();
        }
    }
}

六、整体并发测试

接着上次的测试进行改正：电商系统设计到开发02 单机性能压测-CSDN博客

1 数据准备

用户数：100w，用户ID 1~100_0000，每个用户余额 10w

商品数：100w，商品ID  1~100_0000， 单价都为1元，数量均为1亿件，商家ID均为 100

模拟：1w个用户同时抢购同一件商品

通过查询订单数，账户总金额来核对来验证程序是否正确

测试前总金额为1000 0000 0000

通过查看Jmeter的聚合报告看接口的吞吐量

2 机器准备

我的本地window电脑作为测试机器（i7 13代处理器，32G内存+1T固态硬盘）

使用Wmware 虚拟了4台Centos机器分别是

Centos00 ，1CPU + 2G内存+  20G固态硬盘   |  部署 Consul server，Sentinel Dashboard

Centos01 ，1CPU + 1G内存+  20G固态硬盘   |  部署 MySQL5.7.44

Centos02 ，1CPU + 1G内存+  20G固态硬盘   |  部署 user-center

Centos03 ，1CPU + 1G内存+  20G固态硬盘   |  部署 goods-center

Centos04 ，1CPU + 3G内存+  20G固态硬盘   |  部署 kafka3.5 kraft 3个broker集群模式

 3 压测脚本

随机1w个用户，模拟下订单操作

4 压测 （10000个样本）

100个线程，循环100次

查看结果：

数据库 10000个订单，符合预期，总金额1000 0000 0000符合预期，程序没有问题

聚合报告 （用户请求的吞吐量为295）

kafka消费者总耗时：480秒 

吞吐量 = 10000/480 = 20.8

5 压测总结

下图为没有使用kafka100个线程并发下单的接口测试报告

对比上次没由使用kafka的接口，用户吞请求吐量增加了将近3倍，平均响应时间下降为原来的1/3

但是业务吞吐量，却只有原来的1/5 不到，从查看消费者日志我们可以看到，因为只有一台消费者且用的都是同一个线程，自然吞吐量会很低，下一步，我们考虑如何提升消息吞吐量

七、提升生产者吞吐量

说明：每一步性能的提升，都可能会导致数据安全性的减少

1 生产者相应同步改异步

为了不受消费者影响，我们在启动程序时，先注销消费者代码

单独测试只有生产者代码时的吞吐量，另外加大线上数和循环次数，让差距更加明显一点

采用200线程，200次循环

改造代码，改成默认的异步发送到Kafka，这个改动将有丢失消息的风险

改造前

    public void sendOrderMessageSync(SubmitOrderReq msg) {
        CompletableFuture<SendResult<Long, SubmitOrderReq>> future =
                kafkaTemplate.send(TopicConstants.ORDER_MESSAGE_TOPIC, msg.getOrderId(), msg);
        try {
            // 同步等待发送结果
            SendResult<Long, SubmitOrderReq> result = future.get();
            // 处理成功发送的情况
            log.info("order-message-topic message send successfully: " + result.getRecordMetadata().toString());
        } catch (Exception e) {
            // 处理发送失败的情况
            log.info("order-message-topic message send error message: " + e.getMessage());
            throw new RuntimeException(e);
        }
    }

改造后

    public void sendOrderMessage(SubmitOrderReq msg) {
        log.info("order-message-topic message sending, orderId: {}", msg.getOrderId());
        kafkaTemplate.send(TopicConstants.ORDER_MESSAGE_TOPIC, msg.getOrderId(), msg);
        log.info("order-message-topic message sent, orderId: {}", msg.getOrderId());
    }

改造前吞吐量595

改造后吞吐量663

这种改造提升不明显，吞吐量有微量的提升，不过中位数时延降的比较明显（毕竟是异步立即返回）

2 生产者ack = all 改成ack = 1

表示只要只要master收到消息并落盘就可以返回了

 改造前吞吐量595

改造后吞吐量616

提升不是很明显，可能是因为我使用的是伪集群模式，3台实例都部署在同一个虚拟机中

八、提升消费者吞吐量

这一步，没有部署监视器（前面说了使用Kraft模式部署，太新了，目前可部署的监控还没找到），只能我使用手动计时测试

统计5分钟，数据库生成的订单数

改造前，我们使用之前已经测试过的吞吐量数据 20 

1 增加并发数

执行5分钟后，生成的订单数为：10114

吞吐量为： 10114 / 300 = 33 

原因：因为我创建分区的时候指定的分区数为2，那么即使并发数设置为8，那么也最多只能运行2个线程消费，从下面日志中能验证这一点

2 增加topic分区数

将分区数从2个增加到8个，执行下面命令

bin/kafka-topics.sh --bootstrap-server localhost:9092 --alter --topic order-message-topic --partitions 8

然后发送一些消息到新的分区用于测试

消息准备的好了，清空数据库的订单，开始测试，这次有8个线程进行消费了

测试结果：

吞吐量为： 17910/ 300 = 59

原因：比原来的20吞吐量，已经提升了将近3倍，没有引入Kafka的情况下吞吐量为110，毕竟只有8个线程消费，最高吞吐量的线程数量

3 提交offset改成批量提交

代码改动如下：

// 改动前
containerProperties.setAckMode(ContainerProperties.AckMode.MANUAL_IMMEDIATE);

// 改动后
containerProperties.setAckMode(ContainerProperties.AckMode.MANUAL);

在本章第2步的基础上改进的，所以一会对比第2步

测试结果：

吞吐量为： 18269/ 300 = 60

原因：相对第二步提升不明显，理论上能提升一点点，但是不明显

4 增加消费者机器消费

仍然是8个分区，由原来1台实例，改成现在2台实例，看看吞吐量

在本章第3步的基础改动

测试结果：

吞吐量为： 16878/ 300 = 56

原因：可能是我本地Window的机器消费能力不如Linux虚拟机的消费能力，但是大致看上去，启动2台实例去消费8个分区和启动一台实例开启8个线程去消费8个分区的消费能力是差不多的，当然需要的条件是吞吐量瓶颈不在CPU资源和网络资源上，我的推断我的程序的瓶颈在于数据库，那么8个线程用到的数据库连接数为8个，那么这8个线程决定了吞吐量的大小，为了验证这一猜想，我决定还是增加一小节，将分区数增加到20，并发数增加到20

5 增加分区和并发数为20

20个分区的数据准备好了，接下来开始测试吧

测试结果：

吞吐量为： 18882/ 300 = 62

原因：相比于第3步，增加的不是很明显，说明再提升并发数，性能已经不是很明显了，说明瓶颈不是在这里，要继续优化，估计只能从代码处入手了。

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

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

相关文章

基于Python的全国主要城市天气数据可视化大屏系统

基于Python的全国主要城市天气数据可视化大屏系统

1 绪论 1.1 研究的目的与意义 近年来&#xff0c;气候变化引发全球范围内的关注。天气数据的采集和分析对于气候预测、生态环境保护等方面都起着至关重要的作用。同时&#xff0c;随着科技的不断发展&#xff0c;数据可视化已经成为了许多领域中不可或缺的一部分。基于此&…
阅读更多...
外包干了9个月，技术退步明显.......

外包干了9个月，技术退步明显.......

先说一下自己的情况&#xff0c;大专生&#xff0c;18年通过校招进入武汉某软件公司&#xff0c;干了接近4年的功能测试&#xff0c;今年年初&#xff0c;感觉自己不能够在这样下去了&#xff0c;长时间呆在一个舒适的环境会让一个人堕落! 而我已经在一个企业干了四年的功能测…
阅读更多...
解决 github.com port 443: Timed out 的问题

解决 github.com port 443: Timed out 的问题

国内访问github.com总是那么不竟如人意&#xff0c;时而无法加载网页&#xff0c;时而等我们抽完了一根烟后&#xff0c;它还处于转圈的状态。 虽然国内有gitee.com等诸多的代码托管平台&#xff0c;但却鲜有国人愿意去呢&#xff1f;其中的缘由&#xff0c;想必也不用我多说&a…
阅读更多...
机器学习 | 利用Pandas进入高级数据分析领域

机器学习 | 利用Pandas进入高级数据分析领域

目录 初识Pandas Pandas数据结构 基本数据操作 DataFrame运算 文件读取与存储 高级数据处理 初识Pandas Pandas是2008年WesMcKinney开发出的库&#xff0c;专门用于数据挖掘的开源python库&#xff0c;以Numpy为基础&#xff0c;借力Numpy模块在计算方面性能高的优势&am…
阅读更多...
system_server进程创建流程

system_server进程创建流程

system_server 进程是 Zygote 进程 fork 出的第一个进程&#xff0c;它负责管理和启动整个 Framework 层&#xff0c;下面附上android系统启动流程图&#xff1a; 记得上一篇Zygote进程创建里面提到过&#xff0c;forckSystemServer创建system_server进程。 /frameworks/base/…
阅读更多...
nginx负载均衡-轮询

nginx负载均衡-轮询

实验使用ubuntu做主机 1.安装nginx 安装依赖 sudo apt install libgd-dev 下载nginx wget http://nginx.org/download/nginx-1.22.1.tar.gz 解压nginx tar -zvxf nginx-1.22.1.tar.gz 编译安装 cd nginx-1.22.1 编译并指定安装位置&#xff0c;执行安装之后会创建指定…
阅读更多...
鸿蒙APP的应用场景

鸿蒙APP的应用场景

鸿蒙APP可以用于多种场合和设备类型&#xff0c;这是鸿蒙系统的分布式能力和多终端适配的优势。以下是一些鸿蒙APP的应用场景&#xff0c;希望对大家有所帮助。北京木奇移动技术有限公司&#xff0c;专业的软件外包开发公司&#xff0c;欢迎交流合作。 1.智能手机和平板电脑&am…
阅读更多...
【听力与言语医学中心系列科普16】听力检查之纯音听阈测定

【听力与言语医学中心系列科普16】听力检查之纯音听阈测定

当我们去医院向医生诉说我们耳朵有问题时&#xff0c;最常听到医生说的是“去做个测听”吧&#xff0c;那么什么是测听&#xff1f;做测听有什么作用呢&#xff1f; 一、什么是纯音测听纯音听力测试自1943年Bunch教授发表后&#xff0c;就被作为首选的测听方法。纯音测听是测试…
阅读更多...
一键轻松，免费创造：QuickQR带你体验AI二维码的轻松生成！

一键轻松，免费创造：QuickQR带你体验AI二维码的轻松生成！

当今时代&#xff0c;将信息快速转变为可扫描图案&#xff0c;以简化人们的生活和工作方式&#xff0c;二维码技术展现了它强大的功能。特别是在分享链接、联系信息或进行支付时&#xff0c;二维码已成为现代社会一个不可或缺的部分。本文将探讨生成AI二维码的一种工具&#xf…
阅读更多...
Linux服务器配置与管理（第三次实验）

Linux服务器配置与管理（第三次实验）

实验目的及具体要求 目的 1.熟悉Shell 脚本语法 2.掌握创建脚本的方法 3.掌握运行脚本的方法 4.掌握变量及表达式 5.掌握Shell 控制结构 6.掌握Shell 函数 任务 1.显示当前日期时间、执行路径、用户账户及所在的目录位置 2.判断一个文件是不是字符设备文件&#xff0…
阅读更多...
首发：2024全球DAO组织发展研究

首发：2024全球DAO组织发展研究

作者&#xff0c;张群&#xff08;专注DAO及区块链应用研究&#xff0c;赛联区块链教育首席讲师&#xff0c;工信部赛迪特邀资深专家&#xff0c;CSDN认证业界专家&#xff0c;微软认证专家&#xff0c;多家企业区块链产品顾问&#xff09; DAO&#xff08;去中心化自治组织&am…
阅读更多...
手把手教学:AD09制作BOM及小技巧

手把手教学:AD09制作BOM及小技巧

BOM&#xff08;Bill of Material&#xff09;物料清单&#xff0c;是以数据格式来描述产品结构的文件&#xff0c;即生产一件产品所需的子零件及其产品中零件数量的完全组合。这里生成BOM表用作对你制作的pcb板进行成本预估和制作生产资料文件。同时也是样品制作时&#xff0c…
阅读更多...
2024.1.25 C++QT 作业

2024.1.25 C++QT 作业

思维导图 练习题 1. 自己封装一个矩形类(Rect)&#xff0c;拥有私有属性:宽度(width)、高度(height)&#xff0c; 定义公有成员函数: 初始化函数:void init(int w, int h) 更改宽度的函数:set_w(int w) 更改高度的函数:set_h(int h) 输出该矩形的周长和面积函数:void sh…
阅读更多...
策略者模式-C#实现

策略者模式-C#实现

该实例基于WPF实现&#xff0c;直接上代码&#xff0c;下面为三层架构的代码。 目录 一 Model 二 View 三 ViewModel 一 Model using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks;namespace 设计模式练…
阅读更多...
JavaWeb01--Tomcat

JavaWeb01--Tomcat

1、JavaWeb概述 Web开发是基于请求和响应的&#xff1a; 请求&#xff1a;浏览器&#xff08;客户端&#xff09;向服务器发送信息 响应&#xff1a;服务器向浏览器回送信息 请求和响应是成对出现的。 Web资源分类 所谓Web资源即放在Internet网上供外界访问的文件或程序&#x…
阅读更多...
[java基础揉碎]break跳出循环的标签使用方式(continue同理)

[java基础揉碎]break跳出循环的标签使用方式(continue同理)

语法: (1)break 语句可以指定退出哪层 (2)label1是标签&#xff0c;由程序员指定 (3)break 后指定到哪个label 就退出到哪里 (4)在实际的开发中&#xff0c;尽量不要使用标签(可读性会变差), 除非有业务逻辑需要必须使用迫不得已 (5)如果没有指定break,默认退出最近的循环体…
阅读更多...
new mars3d.layer.WeiVectorTileLayer({在Mars3d官网个api搜索不到的说明

new mars3d.layer.WeiVectorTileLayer({在Mars3d官网个api搜索不到的说明

前景&#xff1a;new mars3d.layer.WeiVectorTileLayer({在Mars3d官网个api搜索不到的说明 说明&#xff1a; 可以下载示例git clone https://gitee.com/marsgis/mars3d-vue-example.git 参考api文档的Cesium.VectorStyle类&#xff0c;这个类可以在示例的thirdParty下面进行…
阅读更多...
sql 行转列 日周月 图表统计

sql 行转列 日周月 图表统计

目录 目录 需求 准备 月 分析 按月分组 行转列 错误版本 正确版本 日 分析 行转列 周 分析 按周分组 行转列 本年 需求 页面有三个按钮 日周月&#xff0c;统计一周中每天(日)&#xff0c;一月中每周(周)&#xff0c;一年中每月(月)&#xff0c;设备台数 点…
阅读更多...
ROS2学习笔记（0）开坑声明

ROS2学习笔记（0）开坑声明

0.前提 在做racecar的过程中发现已经有不少的开发者和公司开始从ros1转向ros2的怀抱了&#xff0c;刚好寒假在家&#xff0c;我就顺带试试看能不能学点ros2&#xff0c;刚好我有两辆车和主板可以双线开工&#xff08;是的&#xff0c;全是老师们赞助的&#xff0c;真的我哭死&…
阅读更多...
DDPM的一点笔记

DDPM的一点笔记

1 Title Denoising Diffusion Probabilistic Models&#xff08;Jonathan Ho、Ajay Jain、Pieter Abbeel&#xff09; 2 Conclusion This paper present high quality image synthesis results using diffusion probabilistic models, a class of latent variable models insp…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023