gitweixin
  • 首页
  • 小程序代码
    • 资讯读书
    • 工具类
    • O2O
    • 地图定位
    • 社交
    • 行业软件
    • 电商类
    • 互联网类
    • 企业类
    • UI控件
  • 大数据开发
    • Hadoop
    • Spark
    • Hbase
    • Elasticsearch
    • Kafka
    • Flink
    • 数据仓库
    • 数据挖掘
    • flume
    • Kafka
    • Hive
    • shardingsphere
    • solr
  • 开发博客
    • Android
    • php
    • python
    • 运维
    • 技术架构
    • 数据库
  • 程序员网赚
  • bug清单
  • 量化投资
  • 在线查询工具
    • 去行号
    • 在线时间戳转换工具
    • 免费图片批量修改尺寸在线工具
    • SVG转JPG在线工具
    • SVG转PDF/Word
    • SVG转Draw.io可二次编辑格式
    • js代码混淆
    • json格式化及任意折叠展开
    • PDF常用工具

Doris Unique模型用于离线数仓的ODS层的好处

精品微信小程序开发门户,代码全部亲测可用

  • 首页   /  
  • 作者: east
  • ( 页面20 )
doris 9月 18,2024

Doris Unique模型用于离线数仓的ODS层的好处

在离线数仓的ODS(Operational Data Store,操作型数据存储)层使用 Doris 的 Unique 模型有多个好处。Doris 提供多种数据模型,其中 Unique 模型专门用于保证数据唯一性,适合一些有去重需求的场景。将 Unique 模型应用于 ODS 层的主要优点包括:

1. 保证数据的唯一性

ODS 层通常存储从源系统抽取的原始数据,这些数据可能存在重复问题。Doris 的 Unique 模型通过唯一键(Primary Key)确保数据的唯一性,避免重复数据的出现。这在整合来自多个源的相同实体时非常重要,比如处理重复的用户、订单、交易等。

2. 便于数据更新

ODS 层的数据可能会发生变化,数据会不断地被更新或增量加载。Doris 的 Unique 模型允许基于唯一键进行记录的更新和覆盖,这使得数据变更(如状态更新、数据修正等)能够方便地应用到表中,而不必执行复杂的删除和插入操作。

3. 提高查询效率

尽管 ODS 层主要用作数据存储的中间层,但在有需要时,也会进行数据查询或分析。Unique 模型通过主键索引提高查询效率,特别是针对带有唯一键的查询。在处理大规模数据时,索引结构可以加速数据检索和聚合查询。

4. 适合维度更新频繁的场景

ODS 层的数据源自多个系统,维度数据的更新可能非常频繁。Doris 的 Unique 模型允许在 ODS 层快速处理这种频繁更新的数据,从而保持数据的最新状态。

5. 简化数据清洗和预处理

在离线数仓的 ODS 层,数据清洗和预处理是重要的步骤。Unique 模型帮助通过去重和数据规范化简化这一过程,确保数据质量,并为后续 DWH 层(数据仓库层)或 DM(数据集市层)的构建奠定坚实基础。

6. 高并发性能

Doris 具有高性能的并行处理能力,支持高并发的数据写入和查询,这对于离线数据仓库中的批量数据处理非常重要。Unique 模型能够高效处理大规模数据的批量导入和更新操作。

7. 灵活的扩展性

ODS 层的数据量通常非常庞大,并且随时间逐步扩展。Doris 的分布式架构和 Unique 模型的设计,支持在集群中进行水平扩展,适应离线数仓 ODS 层的扩展需求。

作者 east
Hbase, Hive 9月 18,2024

写入Hbase报错CallQueueTooBigException的解决

在CDH6.3.2,通过hive外部表插入数据到hbase时报错:

24/09/18 10:43:04 ERROR status.SparkJobMonitor: Spark job[3] failed [INFO] 2024-09-18 10:43:04.156 – [taskAppId=TASK-41-192147-585089]:[127] – -> java.util.concurrent.ExecutionException: Exception thrown by job at org.apache.spark.JavaFutureActionWrapper.getImpl(FutureAction.scala:337) at org.apache.spark.JavaFutureActionWrapper.get(FutureAction.scala:342) at org.apache.hive.spark.client.RemoteDriver$JobWrapper.call(RemoteDriver.java:404) at org.apache.hive.spark.client.RemoteDriver$JobWrapper.call(RemoteDriver.java:365) at java.util.concurrent.FutureTask.run(FutureTask.java:266) at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149) at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624) at java.lang.Thread.run(Thread.java:748) Caused by: org.apache.spark.SparkException: Job aborted due to stage failure: Task 5 in stage 8.0 failed 4 times, most recent failure: Lost task 5.3 in stage 8.0 (TID 85, cdh02, executor 8): java.lang.RuntimeException: Hive Runtime Error while closing operators: org.apache.hadoop.hbase.client.RetriesExhaustedWithDetailsException: Failed 4 actions: CallQueueTooBigException: 4 times, servers with issues: cdh02,16020,1720579381747 at org.apache.hadoop.hive.ql.exec.spark.SparkReduceRecordHandler.close(SparkReduceRecordHandler.java:463) at org.apache.hadoop.hive.ql.exec.spark.HiveReduceFunctionResultList.closeRecordProcessor(HiveReduceFunctionResultList.java:67) at org.apache.hadoop.hive.ql.exec.spark.HiveBaseFunctionResultList.hasNext(HiveBaseFunctionResultList.java:96) at scala.collection.convert.Wrappers$JIteratorWrapper.hasNext(Wrappers.scala:42) at scala.collection.Iterator$class.foreach(Iterator.scala:891) at scala.collection.AbstractIterator.foreach(Iterator.scala:1334) at org.apache.spark.rdd.AsyncRDDActions$$anonfun$foreachAsync$1$$anonfun$apply$12.apply(AsyncRDDActions.scala:127) at org.apache.spark.rdd.AsyncRDDActions$$anonfun$foreachAsync$1$$anonfun$apply$12.apply(AsyncRDDActions.scala:127) at org.apache.spark.SparkContext$$anonfun$38.apply(SparkContext.scala:2232) at org.apache.spark.SparkContext$$anonfun$38.apply(SparkContext.scala:2232) at org.apache.spark.scheduler.ResultTask.runTask(ResultTask.scala:90) at org.apache.spark.scheduler.Task.run(Task.scala:121) at org.apache.spark.executor.Executor$TaskRunner$$anonfun$11.apply(Executor.scala:407) at org.apache.spark.util.Utils$.tryWithSafeFinally(Utils.scala:1408) at org.apache.spark.executor.Executor$TaskRunner.run(Executor.scala:413) at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149) at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624) at java.lang.Thread.run(Thread.java:748) Caused by: org.apache.hadoop.hive.ql.metadata.HiveException: org.apache.hadoop.hbase.client.RetriesExhaustedWithDetailsException: Failed 4 actions: CallQueueTooBigException: 4 times, servers with issues: cdh02,16020,1720579381747 at org.apache.hadoop.hive.ql.exec.FileSinkOperator$FSPaths.closeWriters(FileSinkOperator.java:198) at org.apache.hadoop.hive.ql.exec.FileSinkOperator.closeOp(FileSinkOperator.java:1058) at org.apache.hadoop.hive.ql.exec.Operator.close(Operator.java:686) at org.apache.hadoop.hive.ql.exec.Operator.close(Operator.java:700) at org.apache.hadoop.hive.ql.exec.Operator.close(Operator.java:700) at org.apache.hadoop.hive.ql.exec.Operator.close(Operator.java:700) at org.apache.hadoop.hive.ql.exec.spark.SparkReduceRecordHandler.close(SparkReduceRecordHandler.java:447) … 17 more Caused by: org.apache.hadoop.hbase.client.RetriesExhaustedWithDetailsException: Failed 4 actions: CallQueueTooBigException: 4 times, servers with issues: cdh02,16020,1720579381747 at org.apache.hadoop.hbase.client.BatchErrors.makeException(BatchErrors.java:54) at org.apache.hadoop.hbase.client.AsyncRequestFutureImpl.getErrors(AsyncRequestFutureImpl.java:1226) at org.apache.hadoop.hbase.client.BufferedMutatorImpl.doFlush(BufferedMutatorImpl.java:309) at org.apache.hadoop.hbase.client.BufferedMutatorImpl.close(BufferedMutatorImpl.java:241) at org.apache.hadoop.hive.hbase.HiveHBaseTableOutputFormat$MyRecordWriter.close(HiveHBaseTableOutputFormat.java:130) at org.apache.hadoop.hive.hbase.HiveHBaseTableOutputFormat$MyRecordWriter.close(HiveHBaseTableOutputFormat.java:168) at org.apache.hadoop.hive.ql.exec.FileSinkOperator$FSPaths.closeWriters(FileSinkOperator.java:195)

从错误日志来看,问题出现在通过Hive向HBase写入数据时,具体错误是CallQueueTooBigException,即HBase的请求队列太大,导致数据写入失败。

错误分析:

  1. CallQueueTooBigException:这是HBase的一种负载保护机制。当HBase的RPC队列过载,达到最大处理能力时,会抛出此异常,表示服务器无法处理更多的请求。这通常意味着HBase服务器在写入期间负载过重。
  2. Spark/Hive 与 HBase交互问题:在通过Hive和Spark写入HBase时,数据可能被并行地、大批量地发送给HBase。如果HBase负载过高或者写入并发量过大,可能会出现请求堆积,导致CallQueueTooBigException。
  3. 重试机制:日志中提到”RetriesExhaustedWithDetailsException”,说明Spark在多次重试之后仍然无法成功完成写入操作,导致任务最终失败。

可能的原因:

  1. HBase负载过大:HBase集群可能承受了过多的请求,导致队列超载。
  2. HBase资源不足:HBase服务器的硬件资源(如内存、CPU等)不足,无法处理高并发写入请求。
  3. 写入数据量过大:Hive通过Spark向HBase写入的数据量太大,超过了HBase的处理能力。
  4. 不合理的HBase配置:HBase的写入配置可能设置得过低,例如hbase.regionserver.handler.count(处理器数量)、hbase.rpc.timeout(RPC超时设置)等参数未合理配置。

解决方案:

  1. 调优HBase集群:
    • 增加HBase的处理能力:
      • 增加HBase的RegionServer实例数量。
      • 调整HBase集群的硬件配置,增加内存和CPU资源。
    • 调整HBase配置:
      • 增加hbase.regionserver.handler.count,该参数控制RegionServer可以同时处理的并发请求数量。
      • 调整hbase.ipc.server.max.callqueue.size,增大HBase RPC队列的大小以处理更多的并发请求。
      • 增加hbase.rpc.timeout的值,避免超时过早导致任务失败。
  2. 减少数据写入压力:
    • 批量写入控制:通过Spark作业配置控制每次写入的数据批量大小,减少单次请求的数据量。可以调整Spark配置参数,如spark.sql.shuffle.partitions,以减少分区数。
    • 限制并发写入:如果数据量特别大,可以控制并发写入HBase的作业数量,减小每次写入的压力。
  3. 重试机制配置:
    • 如果错误为临时性问题,可以在HBase客户端或Spark作业中增加重试次数,例如调整hbase.client.retries.number参数,确保在负载压力下仍然有更大的重试机会。
  4. 观察HBase监控日志:使用HBase的监控工具如HBase Web UI或者通过Ganglia等监控工具,观察HBase的RegionServer、请求队列、内存等资源使用情况,找出具体的瓶颈。

作者 east
doris, Hive 9月 18,2024

Doris在离线数仓代替hive的理由

Apache Doris 是一个现代化的MPP(Massively Parallel Processing)数据库,特别适合数据分析和在线查询场景。Doris 在某些情况下可以替代 Hive 作为离线数仓,主要是因为以下几个关键原因:

1. 查询性能

  • 高效的查询执行:Doris 专为高并发和低延迟的查询设计,支持秒级查询响应,特别适合高性能的实时分析需求。
  • 列存储格式:Doris 使用列式存储,能够在查询时只扫描需要的列,大幅减少 I/O,优化了查询性能。相比之下,Hive 的查询速度通常较慢,尤其是对大规模数据集的多维分析。
  • 向量化执行引擎:Doris 引入了向量化执行引擎,这种设计能高效利用 CPU 资源,在批处理数据时能加快计算速度。而 Hive 在执行复杂查询时,性能可能受到较大的开销影响。

2. 支持实时数据加载和更新

  • Doris 支持 流式数据导入,能够做到近实时的数据更新,这对于需要处理不断更新的业务数据的离线数仓场景非常有用。
  • Hive 通常依赖批处理方式更新数据,延迟较高,不能很好地处理实时数据需求。

3. 易用性和生态

  • SQL 兼容性高:Doris 提供丰富的 SQL 语法支持,接近 ANSI SQL 标准,开发人员可以轻松上手,不需要学习新的查询语言。
  • 操作简便:Doris 集成度高,操作简单,支持集群自动容错、自动扩展、负载均衡等功能。而 Hive 的操作复杂度较高,通常依赖 Hadoop 生态中的多个组件(如 YARN、HDFS 等),维护难度较大。
  • 轻量级部署:Doris 的架构更加轻量,不依赖像 Hadoop 这样复杂的集群,降低了基础设施和运维成本。

4. 支持复杂分析场景

  • 多维分析:Doris 支持类似 OLAP(Online Analytical Processing)的多维数据分析,适合进行复杂的聚合和多维度的数据查询。通过并行处理和多种索引机制,Doris 可以在大规模数据场景下快速响应复杂查询需求。
  • Hive 的局限性:Hive 主要是批处理工具,虽然它支持复杂查询,但执行时间通常较长,尤其在需要多维分析和实时交互式查询时表现较差。

5. 数据模型和压缩

  • 自动分区和索引:Doris 支持自动分区和多种索引方式,如倒排索引、位图索引等,极大优化了数据查询的效率。相比之下,Hive 的分区管理较为复杂且手动操作较多。
  • 压缩和存储优化:Doris 采用高效的压缩算法,降低了存储成本。与之相比,Hive 对于数据的存储优化较为有限,依赖底层的 HDFS 文件系统,压缩和解压缩需要额外配置和操作。

6. 高可扩展性和分布式架构

  • Doris 拥有强大的分布式架构,支持大规模集群扩展,能够处理海量数据并保持良好的性能表现。
  • Hive 依赖 Hadoop 分布式文件系统(HDFS),尽管具备扩展性,但性能受限于 Hadoop 集群的配置和调度方式。

7. 统一的存算架构

  • Doris 提供存储和计算紧密耦合的架构,这让数据读取和处理变得更加高效。Hive 则是存算分离的架构,往往需要依赖外部的计算引擎(如 Tez 或 Spark)来执行查询,这带来了额外的计算和数据调度开销。

8. 社区和企业支持

  • Doris 拥有活跃的开源社区,并且在国内外的大型互联网公司中得到了广泛应用。它的发展速度快,更新频繁,支持企业级的使用场景。
  • Hive 作为 Hadoop 生态的一部分,虽然历史悠久,但其发展较为缓慢,主要适用于传统的批处理场景。

总结

Doris 在替代 Hive 作为离线数仓的过程中,主要依赖于其高性能查询、实时数据处理、易用性和更适合复杂多维分析的优势。Doris 对于需要实时响应的数仓场景或大规模多维分析的企业特别具有吸引力,而 Hive 由于其批处理的特性,更适合传统的离线批量计算场景。在新兴的数仓建设中,Doris 是更为现代化的选择。

作者 east
doris, Flink 9月 18,2024

流批一体化,Flink+Doris取代Spark+Hive来开发离线数仓

Flink + Doris 可以作为替代方案,用于开发离线数仓,替代 Spark + Hive 组合。这个架构能够实现更高的性能和实时性,同时简化了架构的复杂性。让我们详细分析一下 Flink + Doris 取代 Spark + Hive 的优点及适用场景:

1. 实时性与流处理能力

  • Flink 的优势:Flink 是一个分布式流处理框架,支持事件驱动和批处理模式,特别擅长处理实时数据流和复杂事件处理(CEP)。Flink 能够以低延迟处理海量数据,确保数据能够迅速进入下游系统。
  • Doris 的实时写入和分析:Doris 支持实时数据加载,能够高效处理来自 Flink 的流式数据,提供秒级查询的响应能力,适合实时数据分析场景。

Spark + Hive 的组合主要用于批处理,Hive 本身不擅长处理实时数据,Spark 的流处理能力也不如 Flink 专注且强大。因此,Flink + Doris 更适合有实时数据需求的场景,尤其是在需要低延迟的业务数据分析和展示时。

2. 查询性能和并发处理

  • Doris 的高效查询:Doris 作为一个专为分析设计的 MPP 数据库,擅长处理大规模数据查询,支持高并发的 SQL 查询并提供低延迟响应,适合在线分析型应用(OLAP)。
  • 列式存储和向量化执行:Doris 使用列式存储和向量化执行引擎,在处理复杂查询时效率更高,能够大幅缩短查询时间。相比之下,Hive 在执行复杂查询时较慢,尤其是基于 HDFS 的查询,依赖磁盘 I/O,性能较差。

Spark + Hive 组合通常需要大量的计算资源来执行批量查询任务,且在查询复杂度上性能不如 Doris。

3. 简化架构与运维成本

  • Flink 和 Doris 的简洁架构:Flink 与 Doris 都具备较高的集成度和易用性,且不依赖于像 Hadoop 这样的复杂生态系统。Flink + Doris 的组合能够简化系统架构,减少数据流动中的延迟,且维护成本相对较低。
  • 轻量级部署:Doris 作为轻量级 OLAP 数据库,部署和运维都较为简单,不需要 Hadoop 的支持。相比之下,Hive 依赖于 Hadoop 生态系统,需要更多的组件(如 HDFS、YARN 等)来保证其工作,这增加了架构的复杂度和运维难度。

Spark + Hive 架构复杂,需要更多的组件支持,部署和维护较为繁琐,Flink + Doris 在这一方面更具优势。

4. 批处理和流处理的统一

  • Flink 批流一体化:Flink 提供了统一的编程模型,能够同时处理批处理和流处理任务,使得离线数仓架构能够更灵活地应对各种数据处理需求。
  • 批处理能力:尽管 Flink 主要以流处理见长,但它在批处理方面的表现也相当出色。通过批流一体化架构,开发人员可以更高效地处理历史数据和实时数据,极大简化了数据处理的开发和运维。

Spark + Hive 则主要关注批处理任务,对于流数据的处理能力相对弱一些。Spark 的流处理框架(Spark Streaming)比 Flink 在复杂流处理上的能力有限。

5. 灵活的数据集成

  • 数据集成与传输:Flink 可以轻松集成各种数据源,包括 Kafka、文件系统、数据库等。它可以将流式和批量数据统一处理后,通过 Doris 实现实时分析和查询。
  • Doris 的多种导入方式:Doris 支持多种数据导入方式,能够高效地处理 Flink 输出的数据流(例如通过 HTTP、Broker、Stream Load 等方式),这使得两者之间的集成非常顺畅。

Spark + Hive 在数据集成的实时性上不如 Flink + Doris。Spark 处理数据后通常还需要依赖 Hive 进行存储和管理,数据查询和更新的延迟较高。

6. 高可扩展性

  • 分布式处理:Flink 作为流处理框架具备出色的可扩展性,能够处理大规模的数据流。Doris 也是一个分布式架构,能够扩展到数百个节点,适应大规模数仓需求。
  • 集群管理:Flink 和 Doris 都支持分布式集群管理,能够根据业务需求动态扩展计算和存储能力。

Spark + Hive 也具有可扩展性,但其扩展性受 Hadoop 生态的限制,复杂性更高。

适用场景

Flink + Doris 适用于需要实时数据处理、高性能查询以及复杂多维分析的场景,如:

  • 实时数据流分析(用户行为分析、监控告警系统)
  • 实时数据仓库(T+0 数据仓库)
  • 多维度的在线查询(报表系统、BI 工具)
  • 需要兼顾批处理和流处理的场景

Spark + Hive 更适用于需要处理大规模离线批量数据且对实时性要求不高的传统数仓场景。

作者 east
mysql, 海豚调度器 9月 18,2024

解决Sqoop从mysql导出数据到hive结果为空时的报错

在海豚调度器1.3.5,用Sqoop从hive导入数据到mysql,有时由于计算结果为空,导致hive的表当天分区的数据为空,Sqoop导出到mysql时报错。海豚调度器设置了失败继续策略也没用,导致后面的工作流没办法继续执行下去。

可以在执行sqoop之前增加判断当天分区的数量是否为空,如果为空就不执行导出。

# 检查分区是否为空
empty=$(hive -S -e "SELECT COUNT(*) FROM cnsaas.ads_bigdata_iot_data WHERE dt='$yesday_date';" | awk '{print $1}')

if [ "$empty" -eq 0 ]; then
  echo "分区为空,不执行 Sqoop 导出。"
else
  echo "分区非空,执行 Sqoop 导出。"

完整的sqoop脚本如下:

#!/bin/bash

# 定义变量
host="your_host"
user="your_user"
pwd="your_password"
yesday_date=$(date -d "yesterday" +%Y-%m-%d)

# 检查分区是否为空
empty=$(hive -S -e "SELECT COUNT(*) FROM cnsaas.ads_bigdata_iot_data WHERE dt='$yesday_date';" | awk '{print $1}')

if [ "$empty" -eq 0 ]; then
  echo "分区为空,不执行 Sqoop 导出。"
else
  echo "分区非空,执行 Sqoop 导出。"
  sqoop export \
    --connect jdbc:mysql://$host:3306/zgcn?characterEncoding=UTF-8 \
    --username $user \
    --password $pwd \
    -m 1 \
    --table ads_bigdata_iot_data\
    --columns stat_date,data_type,stat_type,cu_pid_system_code,max_value,min_value,avg_value \
    --fields-terminated-by '\001' \
    --update-key stat_date,data_type,stat_type,cu_pid_system_code \
    --update-mode allowinsert \
    --input-null-string '\\N' \
    --input-null-non-string '\\N' \
    --null-string '\\N' --null-non-string '\\N' \
    --export-dir /user/hive/warehouse/cnsaas.db/ads_bigdata_iot_data/dt=$yesday_date/*
fi
作者 east
python 9月 18,2024

selenium解决调用Chrome str’ object has no attribute ‘capabilities’ Process finished

使用selenium调用chrome进行自动化测试,时不时报错:

原来代码如下:

path_to_chromedriver = 'C:/Program Files (x86)/Google/Chrome/Application/chromedriver.exe'
5driver = webdriver.Chrome(executable_path=path_to_chromedriver)

报错如下:

上面的代码修改后报错:Traceback (most recent call last): File “D:\program files\Python\Python39\lib\site-packages\selenium\webdriver\common\driver_finder.py”, line 38, in get_path path = SeleniumManager().driver_location(options) if path is None else path File “D:\program files\Python\Python39\lib\site-packages\selenium\webdriver\common\selenium_manager.py”, line 76, in driver_location browser = options.capabilities[“browserName”] AttributeError: ‘str’ object has no attribute ‘capabilities’ During handling of the above exception, another exception occurred: Traceback (most recent call last): File “D:\newcode\pythonProject\gpt\doubao_csdn.py”, line 130, in <module> reader = FunnyScriptsReader(directory) File “D:\newcode\pythonProject\gpt\doubao_csdn.py”, line 21, in __init__ self.driver = webdriver.Chrome(“executable_path=C:\Program Files (x86)\Google\Chrome\Application\chromedriver.exe”) File “D:\program files\Python\Python39\lib\site-packages\selenium\webdriver\chrome\webdriver.py”, line 45, in __init__ super().__init__( File “D:\program files\Python\Python39\lib\site-packages\selenium\webdriver\chromium\webdriver.py”, line 51, in __init__ self.service.path = DriverFinder.get_path(self.service, options) File “D:\program files\Python\Python39\lib\site-packages\selenium\webdriver\common\driver_finder.py”, line 40, in get_path msg = f”Unable to obtain driver for {options.capabilities[‘browserName’]} using Selenium Manager.” AttributeError: ‘str’ object has no attribute ‘capabilities’ Process finished with exit code 1

在最新版本的Selenium中,推荐的做法是使用 service 模块,并且不再推荐使用 executable_path。因此,更好的实践是创建一个 Service 实例,,并传入 ChromeDriver 的路径:(
顺利解决了上面的问题 )


from selenium import webdriver
from selenium.webdriver.chrome.service import Service

# 替换为实际的ChromeDriver路径
path_to_chromedriver = ‘C:/Program Files (x86)/Google/Chrome/Application/chromedriver.exe’
service = Service(executable_path=path_to_chromedriver)

# 创建WebDriver实例
driver = webdriver.Chrome(service=service)

作者 east
Flink 9月 14,2024

Flink中的窗口与传统数据库中的窗函数有何不同?

Flink中的窗口与传统数据库中的窗函数主要有以下几个方面的不同:

  1. 实时处理与批处理的差异:Flink是专为实时数据流处理设计的,其窗口机制能够处理无限数据流,并支持事件时间和处理时间的概念。相比之下,传统数据库中的窗函数通常用于批处理,处理的是有界数据集。 
  2. 窗口类型的多样性:Flink提供了多种窗口类型,包括滚动窗口、滑动窗口、会话窗口和全局窗口,这些窗口可以根据时间或计数来定义。而传统数据库中的窗函数通常较为基础,主要是基于时间的窗口聚合。 
  3. 窗口函数的实现:Flink中的窗口函数不仅支持全量聚合,还支持增量聚合,后者在性能上更为优越,特别是在处理大规模数据流时。此外,Flink的窗口函数可以与触发器结合使用,以控制窗口的计算时机。 
  4. 时间语义的明确性:Flink的窗口函数在处理事件时间时提供了明确的时间语义,这对于确保实时数据分析的准确性至关重要。而传统数据库中的窗函数通常不涉及事件时间的概念。 
  5. 窗口的动态创建:Flink中的窗口是动态创建的,只有当窗口内的数据到达时才会创建相应的窗口,这有助于优化内存使用和计算资源。 
作者 east
python 9月 14,2024

python AttributeError: ‘NoneType’ object has no attribute ‘open’

在写python关闭数据库连接时,代码报错: AttributeError: ‘NoneType’ object has no attribute ‘open’ 。这是因为 connection 在 finally 块中可能仍然是 None,而尝试对 None 类型的对象调用 .open 方法会引发此错误。

为了修复这个问题,我们需要更精确地控制 connection 的使用。在 finally 块中,应该确保 connection 既不为 None 也必须是一个有效的连接对象。因此,可以通过检查 connection 是否不为 None 来避免此错误,同时简化 finally 块的处理逻辑。

修改后的正确代码如下:

  def get_charge_electric(self, day, bms_pid_system_code, charge_type):
        connection = None
        cursor = None
        try:
            connection = pymysql.connect(**self.db_config)
            cursor = connection.cursor(pymysql.cursors.DictCursor)

            # 判断charge_type是charge_electric还是discharge_electric,并在query替换
            if charge_type == 'charge_electric':
                query = """
                    SELECT charge_electric 
                    FROM bigdata_test_electric_day 
                    WHERE day = %s AND bms_pid_system_code = %s
                """
            else:
                query = """
                    SELECT discharge_electric
                    FROM bigdata_test_electric_day 
                    WHERE day = %s AND bms_pid_system_code = %s
                """

            cursor.execute(query, (day, bms_pid_system_code))
            result = cursor.fetchone()

            return result[charge_type] if result else None
        except pymysql.MySQLError as e:
            print(f"Error: {e}")
            return None
        finally:
            if cursor is not None:
                cursor.close()
            if connection is not None:
                connection.close()
作者 east
tdengine 9月 12,2024

tdengine存放的数据是类似mysql那样吗

TDengine 存放的数据并不完全类似于 MySQL。虽然两者都是数据库管理系统,但它们的设计目标、数据组织方式和存储结构有着本质的不同。

数据组织方式:

  • TDengine:它专为处理时序数据设计,因此其数据组织方式也充分考虑到了这一点。TDengine 将每一个采集点的数据作为数据库中的一张独立的表来存储,这种设计使得对于特定采集点的数据,无论是内存还是硬盘上的数据点都可以被快速访问 1。此外,TDengine 还引入了超级表(Super Table)的概念,允许用户定义一组具有相同模式(schema)的表,从而简化数据管理和查询。
  • MySQL:作为一个通用的关系型数据库,MySQL 主要处理的是关系型数据,即数据之间的关系可以通过外键等机制建立起来。MySQL 中的数据组织通常是基于表的,表与表之间通过关联关系进行链接,形成复杂的数据模型。

数据存储结构:

  • TDengine:采用了列式存储的方式,这有助于提高压缩和查询效率。TDengine 还引入了虚拟数据节点(vnode)的概念,每个 vnode 负责为采集的时序数据提供写入、查询和计算的功能,同时便于负载均衡、数据恢复和支持异构环境 10。存储的数据包括时序数据以及库、表相关的元数据、标签数据等,这些数据具体分为时序数据,存放于 vnode 里,由 data、head 和 last 三个文件组成 4。
  • MySQL:则主要基于行存储,尽管 MySQL 的 InnoDB 引擎也支持行级锁定和某些形式的数据压缩,但它的设计初衷是为了支持事务处理和复杂的 SQL 查询,因此在数据存储上更注重事务的一致性和隔离性。

性能比较:

  • 写入性能:TDengine 相对于 MySQL 在写入性能方面表现出显著的优势,尤其在处理大规模数据集时,TDengine 可以通过简单调整虚拟节点数量的方式来获得更高的写入性能,并且针对大数据集写入场景展现出了更大的性能优势 2。在一些性能测试中,TDengine 的插入速度远远超过了 MySQL,尤其是在并发写入时表现更佳 7。
作者 east
tdengine 9月 12,2024

TDengine 和 MySQL 在数据查询方面有哪些区别?

TDengine 和 MySQL 在数据查询方面的区别主要体现在以下几个方面:

查询性能

  • TDengine:由于专为时序数据设计,TDengine 在处理时序数据查询时通常会有更好的性能。它采用了列式存储和数据压缩技术,这使得在查询大量时间序列数据时能够更快地从磁盘加载数据,并且减少了数据传输的带宽需求。此外,TDengine 的查询优化器可能会针对时序数据的特点进行专门的优化,例如对时间范围的快速定位和过滤。
  • MySQL:虽然 MySQL 也可以处理时序数据,但由于它是为通用关系型数据设计的,所以在处理大规模时间序列数据时可能不如 TDengine 高效。MySQL 的查询优化器通常需要处理更多的索引和复杂的 SQL 语句,这可能会导致在大规模数据集上的查询性能下降。

查询语言

  • TDengine:使用一种简单的 SQL-like 查询语言,但它针对时序数据做了特定的扩展,支持一些特殊的函数,如聚合函数,这些函数特别适合处理时间序列数据。例如,它可以很容易地实现时间窗口内的数据聚合、滑动窗口计算等功能。
  • MySQL:使用标准的 SQL 查询语言,支持丰富的查询功能,包括复杂的连接操作、子查询、事务处理等。MySQL 的查询语言更加通用,可以处理各种类型的数据和查询需求。

扩展性和并行处理

  • TDengine:设计了分布式架构,可以在多个节点上水平扩展,利用多核 CPU 并行处理查询请求。这意味着 TDengine 在大规模数据集上的查询可以利用集群中的多台机器来加速查询响应时间。
  • MySQL:虽然 MySQL 也有分布式和集群解决方案(如 MySQL Cluster),但在默认情况下,它并不是为大规模分布式查询设计的。MySQL 的扩展性更多依赖于主从复制、分片(Sharding)等技术。

数据模型

  • TDengine:支持超级表(Super Table)的概念,这是一种用来存储大量具有相同模式(schema)的表的方法,这使得对相似数据的查询变得非常高效。超级表可以帮助简化数据管理和查询,特别是在 IoT 场景下,很多设备产生的数据格式是一致的。
  • MySQL:支持传统的表和视图模型,数据查询通常需要明确指定表名和字段,对于具有相同模式的数据,MySQL 可能需要多个表来表示,这增加了查询的复杂性。

特定功能

  • TDengine:提供了针对时序数据的一些特定功能,如自动数据过期处理、数据压缩、实时数据分析等。这些功能使得 TDengine 在处理时间序列数据时更加得心应手。
  • MySQL:虽然也可以通过插件或者第三方工具来增强其处理时序数据的能力,但它并不是专门为这些功能设计的。

总的来说,TDengine 和 MySQL 在数据查询方面的设计目标和服务场景不同。TDengine 以其高效的时序数据处理能力,在物联网、监控系统等领域有较好的表现;而 MySQL 则因其通用性和广泛的适用性,在各种数据库应用中都有很好的表现。选择哪种数据库取决于具体的应用需求和数据特性。

作者 east
Android 9月 11,2024

什么是Android ANR 是什么?怎样避免和解决 ANR?

ndroid 中的 ANR 全称为 Application Not Responding,即应用程序无响应。在 Android 里,应用程序的响应性是由 Activity Manager 和 Window Manager 系统服务监视的。当出现以下情况时,Android 会针对特定的应用程序显示 ANR:在 5 秒内没有响应输入的事件(如按键按下、屏幕触摸);BroadcastReceiver 在 10 秒内没有执行完毕;Service 的各个生命周期函数在特定时间(20 秒)内无法完成处理。
为避免 ANR,可以采取以下措施:

  1. 运行在主线程里的任何方法都应尽可能少做事情。Activity 应在关键生命周期方法(如 onCreate () 和 onResume ())里尽可能少地做创建操作。
  2. 潜在的耗时操作,如网络或数据库操作、高耗时的计算如改变位图尺寸,应在子线程里(或通过异步请求的方式)来完成。主线程应为子线程提供一个 Handler,以便完成时能够提交给主线程。
  3. IntentReceiver 应在后台做小的、琐碎的工作如保存设定或者注册一个 Notification,避免在 BroadcastReceiver 里做耗时的操作或计算。如果响应 Intent 广播需要执行一个耗时的动作,应启动一个 Service。
  4. 单独开工作者线程,通过独立的 Thread 或使用类似 AsyncTask 的方式来处理耗时的内容。
  5. 耗时的操作尽量分段处理,使用类似状态机的方法。
  6. UI 线程中不要处理过多的内容,遇到复杂的 UI 操作可参考分段处理方式。
  7. 使用异步任务,将耗时操作转移到后台线程(如使用 AsyncTask、HandlerThread、ExecutorService 等)、异步任务、后台服务,确保主线程专注于 UI 更新和事件处理。
  8. 避免死锁和过度同步,在多线程编程中,合理使用锁机制和同步策略,确保线程安全地访问共享资源。
  9. 资源竞争管理,避免多个线程同时访问共享资源导致的资源竞争问题。

解决 ANR 的方法有:

  1. 异步化处理,使用异步任务将耗时操作转移到后台线程,避免主线程阻塞。
  2. 分析 traces.txt 文件,ANR 发生时,系统会在设备上生成 traces.txt 文件,它记录了所有线程的状态,通过 ADB 工具将其导出分析,可以定位到具体哪个线程可能引起阻塞。
  3. 使用性能分析工具,如 Android Profiler 实时监控 CPU、内存、网络、磁盘 I/O 等资源使用情况,寻找可能导致 ANR 的性能瓶颈;Systrace 系统层级的跟踪工具,能够追踪系统各组件间的交互和调度,帮助找出主线程阻塞的源头;使用 Android 提供的 ANR 检测工具,如 Traceview,可以获取应用程序的执行堆栈信息,通过分析堆栈信息,可以准确找到导致 ANR 的代码位置。
  4. 通过在开发工具中进行调试和单步执行,可以逐步跟踪代码的执行过程,找到导致 ANR 的具体位置和原因。

Android ANR 的定义和触发条件

ANR,即 Application Not Responding,应用程序无响应。在 Android 中,应用程序的响应性是由 Activity Manager 和 Window Manager 系统服务监视的。当出现以下情况时,Android 就会针对特定的应用程序显示 ANR:

  1. 在 5 秒内没有响应输入的事件(例如,按键按下,屏幕触摸)。这种情况通常发生在主线程被长时间占用,无法及时处理用户的输入事件。比如,当用户点击屏幕上的按钮时,主线程应该尽快响应这个事件。如果主线程正在执行一个耗时的操作,如进行大量的计算或者进行网络请求,就可能无法在规定的时间内响应这个点击事件,从而触发 ANR。
  2. BroadcastReceiver 在 10 秒内没有执行完毕。当接收到广播时,BroadcastReceiver 的 onReceive 方法会在主线程中执行。如果这个方法执行时间过长,就会触发 ANR。例如,在 onReceive 方法中进行复杂的数据库操作或者网络请求,都可能导致 ANR 的发生。
  3. Service 前台 20 秒后台 200 秒未完成启动。当启动一个服务时,如果服务的各个生命周期函数在规定的时间内没有完成执行,也会触发 ANR。比如,在服务的 onCreate 方法中进行耗时的初始化操作,可能会导致服务无法在规定时间内启动,从而触发 ANR。
  4. ContentProvider 的 publish 在 10s 内没进行完。ContentProvider 在发布数据时,如果在规定时间内没有完成操作,也会触发 ANR。

如何在主线程减少操作避免 ANR

运行在主线程里的任何方法都尽可能少做事情。特别是,Activity 应该在它的关键生命周期方法(如 onCreate () 和 onResume ())里尽可能少的去做创建操作。
在 Activity 的 onCreate () 和 onResume () 方法中,应该避免进行耗时的操作。例如,不要在这些方法中进行网络请求、数据库操作或者大量的计算。这些操作应该放在子线程中执行,以避免阻塞主线程。
例如,可以在 onCreate () 方法中只进行一些必要的初始化工作,如设置布局、初始化一些基本的变量等。如果需要从网络获取数据来填充界面,可以在 onCreate () 方法中启动一个子线程,在子线程中进行网络请求,当数据获取完成后,再通过 Handler 或者其他方式将数据传递给主线程,更新 UI。
此外,在主线程中也应该避免大量创建新对象。大量创建新对象会消耗大量的内存和时间,可能导致主线程卡顿,从而触发 ANR。可以考虑使用对象池等技术来减少对象的创建和销毁次数。

利用子线程避免 ANR 的方法

为了避免 ANR,应该把耗时任务放在后台线程执行。在 Android 中,可以使用 AsyncTask、HandlerThread、或 Thread 来执行异步操作。

  1. 使用 AsyncTask:AsyncTask 是一个异步任务类,比 Handler 更轻量,更适合简单的异步操作。内部实现了对 Thread 和 Handler 的封装,方便后台线程操作后 UI 的更新。在用 AsyncTask 进行 UI 更新时,不用额外创建 Handler,直接用 AsyncTask 内部封装好的几个方法。例如,可以在 doInBackground 方法中执行耗时的操作,如网络请求或数据库操作,在 onPostExecute 方法中更新 UI。
  2. 使用 HandlerThread:HandlerThread 是一个带有消息循环的线程。可以通过创建 HandlerThread,然后获取其 Looper,创建一个 Handler,在 Handler 中处理耗时任务。例如,可以在 Handler 的 handleMessage 方法中执行耗时的操作,当操作完成后,通过发送消息给主线程的 Handler,更新 UI。
  3. 使用 Thread:可以直接创建一个新的 Thread,在 Thread 的 run 方法中执行耗时任务。当任务完成后,需要在主线程中更新 UI 时,可以通过 Handler 或者 runOnUiThread 方法来实现。例如,可以在 Thread 的 run 方法中进行网络请求,当请求完成后,通过 runOnUiThread 方法在主线程中更新 UI。

IntentReceiver 避免 ANR 的方式

IntentReceiver 执行时间的特殊限制意味着它应该做小的、琐碎的工作如保存设定或者注册一个 Notification。应用程序应该避免在 BroadcastReceiver 里做耗时的动作。
如果响应 Intent 广播需要执行一个耗时的动作的话,应用程序应该启动一个 Service。例如,当接收到一个广播时,如果需要进行网络请求或者数据库操作等耗时操作,不应该在 BroadcastReceiver 的 onReceive 方法中直接执行这些操作,而是应该启动一个 Service,在 Service 中执行这些耗时操作。
避免在 Intent Receiver 里启动一个 Activity,因为它会创建一个新的画面,并从当前用户正在运行的程序上抢夺焦点。如果你的应用程序在响应 Intent 广播时需要向用户展示什么,你应该使用 Notification Manager 来实现。

使用异步任务避免 ANR

使用异步任务可以避免 ANR 问题。异步任务是一种在后台线程执行耗时操作的机制,可以避免在主线程中执行耗时操作导致界面卡顿的问题。
在 Android 中,媒体播放通常涉及到加载媒体文件、解码、缓冲、播放等多个步骤,这些操作都是耗时的。如果在主线程中执行这些操作,会导致界面无响应,用户体验差。因此,使用异步任务来处理媒体播放可以保证界面的流畅性。
异步任务播放媒体的步骤如下:创建一个继承自 AsyncTask 的子类,用于执行媒体播放操作。在 AsyncTask 子类中,重写 doInBackground () 方法,在该方法中执行耗时的媒体播放操作,如加载媒体文件、解码等。在 doInBackground () 方法中,可以使用 MediaPlayer 类或其他媒体播放库来实现具体的媒体播放功能。在 AsyncTask 子类中,可以重写其他方法,如 onPreExecute ()、onPostExecute () 等,用于在任务执行前后进行一些准备工作和处理结果。在主线程中,通过创建 AsyncTask 子类的实例,并调用 execute () 方法来启动异步任务。

UI 线程处理过多内容如何避免 ANR

UI 线程尽量只做 UI 相关的操作,避免耗时操作,比如过度复杂的 UI 绘制、网络操作、文件 IO 操作等。
如果 UI 线程处理过多内容,可能会导致主线程卡顿,从而触发 ANR。为了避免这种情况,可以采取以下措施:

  1. 优化 UI 布局:避免布局层级过深,使用 ConstraintLayout 等高效的布局方式,减少布局的复杂性。
  2. 延迟加载布局:使用 ViewStub 等技术,延迟加载布局,避免在初始化时加载过多的布局,从而减少 UI 线程的负担。
  3. 异步加载数据:对于需要从网络或数据库获取的数据,可以在子线程中进行加载,加载完成后再更新 UI。
  4. 使用高效的视图组件:如 RecyclerView 等,提高数据的展示效率,减少 UI 线程的负担。

避免死锁和过度同步防止 ANR

在多线程编程中,合理使用锁机制和同步策略,避免死锁和过度同步的情况发生。确保线程安全地访问共享资源。
例如,可以使用 ReentrantLock 等锁机制,避免多个线程同时访问共享资源导致的死锁问题。在使用锁时,要注意锁的范围,避免长时间持有锁,导致其他线程无法访问共享资源。
同时,要避免过度同步,即不要在不必要的地方使用同步机制,导致程序性能下降。可以通过分析程序的逻辑,确定哪些地方需要使用同步机制,哪些地方可以不用。

资源竞争管理避免 ANR

避免多个线程同时访问共享资源导致的资源竞争问题。
可以通过以下方式来管理资源竞争:

  1. 使用锁机制:如 ReentrantLock、synchronized 等,确保同一时间只有一个线程访问共享资源。
  2. 使用信号量:可以限制同时访问共享资源的线程数量。
  3. 使用线程安全的集合类:如 ConcurrentHashMap 等,避免在多线程环境下出现数据不一致的问题。

异步化处理解决 ANR

  1. 使用异步任务:将耗时操作转移到后台线程(如使用 AsyncTask、HandlerThread、ExecutorService 等)、异步任务、后台服务。确保主线程专注于 UI 更新和事件处理。
    • 创建一个固定大小的线程池,大小为 4。例如,可以使用 Executors.newFixedThreadPool (4) 创建一个固定大小为 4 的线程池。
    • 假设有一个耗时任务,可以创建一个 Runnable 对象,在 run 方法中实现耗时操作,如 doSomeHeavyWork ()。
    • 将耗时任务提交给线程池执行,可以使用 executorService.execute (longRunningTask) 将耗时任务提交给线程池执行。
  2. 避免死锁和过度同步:在多线程编程中,合理使用锁机制和同步策略,避免死锁和过度同步的情况发生。确保线程安全地访问共享资源。
    • 例如,可以使用 ReentrantLock 等锁机制,避免多个线程同时访问共享资源导致的死锁问题。在使用锁时,要注意锁的范围,避免长时间持有锁,导致其他线程无法访问共享资源。
    • 同时,要避免过度同步,即不要在不必要的地方使用同步机制,导致程序性能下降。可以通过分析程序的逻辑,确定哪些地方需要使用同步机制,哪些地方可以不用。
  3. 资源竞争管理:避免多个线程同时访问共享资源导致的资源竞争问题。
    • 可以通过使用锁机制、信号量、线程安全的集合类等方式来管理资源竞争。

分析 traces.txt 文件解决 ANR

当 ANR 发生时,系统会将 ANR 信息输出到 traces.txt 文件中。这个文件记录了在发生 ANR 时刻系统各个线程的执行状态。
可以通过以下步骤分析 traces.txt 文件:

  1. 获取 traces.txt 文件:可以使用 adb 命令将 traces.txt 文件从设备中导出到本地。例如,可以在命令行中进入 Android SDK 的 platform-tools 目录,然后执行 adb pull /data/anr/traces.txt 命令,将 traces.txt 文件导出到当前目录。
  2. 分析文件内容:打开 traces.txt 文件,可以看到文件中记录了发生 ANR 的时间、进程 id、进程名称等信息。后面还记录了各个线程的基本信息,如线程名称、线程的优先级、线程锁 id 和线程状态等。
    • 通过分析这些信息,可以确定导致 ANR 的原因。例如,如果发现某个线程长时间处于阻塞状态,可能是因为这个线程在等待某个资源,或者在执行一个耗时的操作。
    • 可以根据文件中的调用栈信息,确定导致 ANR 的具体代码位置。然后,可以针对这个问题进行修复。

使用性能分析工具解决 ANR

可以使用一些性能分析工具来帮助定位和解决 ANR 问题。

  1. Traceview:系统性能分析工具,用于定位应用代码中的耗时操作。可以通过在 Android Studio 中运行应用,然后在工具栏中选择 “Profile” 按钮,启动 Traceview 工具。Traceview 可以显示应用程序中各个方法的执行时间,帮助开发者找出耗时的操作,从而进行优化。
  2. Systrace:Android 4.1 新增的应用性能数据采样和分析工具。可以通过在命令行中执行 systrace.py 脚本,启动 Systrace 工具。Systrace 可以收集系统级别的性能数据,包括 CPU 使用情况、线程状态、图形渲染等信息,帮助开发者分析应用程序的性能问题。

通过调试单步执行解决 ANR

在调试过程中,如果遇到 ANR 问题,可以使用调试工具进行单步跟踪,分析问题所在。
例如,可以在 Android Studio 中设置断点,然后使用调试工具进行单步跟踪。通过观察程序的执行流程,可以确定导致 ANR 的原因。
如果在断点或者单步跟踪时 APP 退出,可能是因为出现了 ANR。可以通过打开手机开发者模式,在 “开发人员选项” 中,向下滚动到 “调试” 部分,然后在 “选择调试应用” 中选择你的应用。这样,当在断点中暂停时,它不会触发任何 ANR。


结论:ANR 是 Android 中应用程序无响应的情况,会严重影响用户体验。为了避免和解决 ANR 问题,可以从多个方面入手。在主线程中减少操作,避免进行耗时的操作,如网络请求、数据库操作和大量计算等。利用子线程执行耗时任务,如使用 AsyncTask、HandlerThread 或 Thread 等方式。在 IntentReceiver 中避免做耗时操作,如有需要可以启动 Service 来处理。使用异步任务可以有效地避免 ANR 问题,如异步任务播放媒体等。同时,要注意 UI 线程的负担,避免处理过多内容导致卡顿。避免死锁和过度同步,合理管理资源竞争,通过异步化处理、分析 traces.txt 文件和使用性能分析工具等方式,可以帮助定位和解决 ANR 问题。在调试过程中,要注意避免因调试导致的 ANR 问题。通过以上措施,可以有效地提高 Android 应用程序的性能和稳定性,避免 ANR 的发生。

作者 east
Android 8月 27,2024

为什么要在Android中使用独立进程来运行长连接逻辑?

在Android中使用独立进程来运行长连接逻辑的主要原因是为了提高应用的稳定性和安全性。当长连接逻辑在独立进程中运行时,即使该进程因为长连接相关的错误而崩溃,也不会影响到主进程,即应用的UI界面和其他功能仍然可以正常工作。这样可以避免因为网络错误或其他问题导致整个应用崩溃,提升用户体验。

此外,独立进程还可以提供更好的资源隔离,确保长连接不会占用主进程的资源,如内存和CPU,这对于资源受限的移动设备尤为重要。独立进程还可以更方便地进行调试和管理,因为它可以被视作一个独立的服务或组件。

在Android开发中,可以通过在应用的AndroidManifest.xml文件中为服务或组件设置android:process属性来指定它们运行在独立进程中。这种做法在需要长时间运行、与应用其他部分交互较少的服务中尤为常见,如网络同步、推送通知服务等。通过这种方式,开发者可以更好地控制应用的行为,确保即使在网络或服务不稳定的情况下,应用的核心功能也能保持稳定运行。

作者 east

上一 1 … 19 20 21 … 93 下一个

关注公众号“大模型全栈程序员”回复“小程序”获取1000个小程序打包源码。回复”chatgpt”获取免注册可用chatgpt。回复“大数据”获取多本大数据电子书

标签

AIGC AI创作 bert chatgpt github GPT-3 gpt3 GTP-3 hive mysql O2O tensorflow UI控件 不含后台 交流 共享经济 出行 图像 地图定位 外卖 多媒体 娱乐 小程序 布局 带后台完整项目 开源项目 搜索 支付 效率 教育 日历 机器学习 深度学习 物流 用户系统 电商 画图 画布(canvas) 社交 签到 联网 读书 资讯 阅读 预订

官方QQ群

小程序开发群:74052405

大数据开发群: 952493060

近期文章

  • 解决gitlab配置Webhooks,提示 Invalid url given的问题
  • 如何在Chrome中设置启动时自动打开多个默认网页
  • spark内存溢出怎样区分是软件还是代码原因
  • MQTT完全解析和实践
  • 解决运行Selenium报错:self.driver = webdriver.Chrome(service=service) TypeError: __init__() got an unexpected keyword argument ‘service’
  • python 3.6使用mysql-connector-python报错:SyntaxError: future feature annotations is not defined
  • 详解Python当中的pip常用命令
  • AUTOSAR如何在多个供应商交付的配置中避免ARXML不兼容?
  • C++thread pool(线程池)设计应关注哪些扩展性问题?
  • 各类MCAL(Microcontroller Abstraction Layer)如何与AUTOSAR工具链解耦?

文章归档

  • 2025年12月
  • 2025年10月
  • 2025年8月
  • 2025年7月
  • 2025年6月
  • 2025年5月
  • 2025年4月
  • 2025年3月
  • 2025年2月
  • 2025年1月
  • 2024年12月
  • 2024年11月
  • 2024年10月
  • 2024年9月
  • 2024年8月
  • 2024年7月
  • 2024年6月
  • 2024年5月
  • 2024年4月
  • 2024年3月
  • 2023年11月
  • 2023年10月
  • 2023年9月
  • 2023年8月
  • 2023年7月
  • 2023年6月
  • 2023年5月
  • 2023年4月
  • 2023年3月
  • 2023年1月
  • 2022年11月
  • 2022年10月
  • 2022年9月
  • 2022年8月
  • 2022年7月
  • 2022年6月
  • 2022年5月
  • 2022年4月
  • 2022年3月
  • 2022年2月
  • 2022年1月
  • 2021年12月
  • 2021年11月
  • 2021年9月
  • 2021年8月
  • 2021年7月
  • 2021年6月
  • 2021年5月
  • 2021年4月
  • 2021年3月
  • 2021年2月
  • 2021年1月
  • 2020年12月
  • 2020年11月
  • 2020年10月
  • 2020年9月
  • 2020年8月
  • 2020年7月
  • 2020年6月
  • 2020年5月
  • 2020年4月
  • 2020年3月
  • 2020年2月
  • 2020年1月
  • 2019年7月
  • 2019年6月
  • 2019年5月
  • 2019年4月
  • 2019年3月
  • 2019年2月
  • 2019年1月
  • 2018年12月
  • 2018年7月
  • 2018年6月

分类目录

  • Android (73)
  • bug清单 (79)
  • C++ (34)
  • Fuchsia (15)
  • php (4)
  • python (45)
  • sklearn (1)
  • 云计算 (20)
  • 人工智能 (61)
    • chatgpt (21)
      • 提示词 (6)
    • Keras (1)
    • Tensorflow (3)
    • 大模型 (1)
    • 智能体 (4)
    • 深度学习 (14)
  • 储能 (44)
  • 前端 (5)
  • 大数据开发 (497)
    • CDH (6)
    • datax (4)
    • doris (31)
    • Elasticsearch (15)
    • Flink (79)
    • flume (7)
    • Hadoop (19)
    • Hbase (23)
    • Hive (41)
    • Impala (2)
    • Java (71)
    • Kafka (10)
    • neo4j (5)
    • shardingsphere (6)
    • solr (5)
    • Spark (100)
    • spring (11)
    • 数据仓库 (9)
    • 数据挖掘 (7)
    • 海豚调度器 (10)
    • 运维 (39)
      • Docker (3)
  • 小游戏代码 (1)
  • 小程序代码 (139)
    • O2O (16)
    • UI控件 (5)
    • 互联网类 (23)
    • 企业类 (6)
    • 地图定位 (9)
    • 多媒体 (6)
    • 工具类 (25)
    • 电商类 (22)
    • 社交 (7)
    • 行业软件 (7)
    • 资讯读书 (11)
  • 嵌入式 (71)
    • autosar (63)
    • RTOS (1)
    • 总线 (1)
  • 开发博客 (16)
    • Harmony (9)
  • 技术架构 (6)
  • 数据库 (32)
    • mongodb (1)
    • mysql (13)
    • pgsql (2)
    • redis (1)
    • tdengine (4)
  • 未分类 (8)
  • 程序员网赚 (20)
    • 广告联盟 (3)
    • 私域流量 (5)
    • 自媒体 (5)
  • 量化投资 (4)
  • 面试 (14)

功能

  • 登录
  • 文章RSS
  • 评论RSS
  • WordPress.org

All Rights Reserved by Gitweixin.本站收集网友上传代码, 如有侵犯版权,请发邮件联系yiyuyos@gmail.com删除.