flink消费kafka数据写入阿里hologres(java版)

moshang_find moshang_find 博客等级 码龄10年
关注
原创 最新推荐文章于 2026-08-06 13:36:24 发布 2k 阅读 开通墨衍会员： AI 帮你选题成稿，GEO 检测让 AI 也搜得到
flink应用一(从Kafka消费数据写入MySQL) 前言 最近flink已经变得比较流行了，所以大家要了解flink并且使用flink。现在最流行的实时计算应该就是flink了，它具有了流计算和批处理功能。它可以处理有界数据和无界数据，也就是可以处理永远生产的数据。具体的细节我们不讨论，我们直接搭建一个flink功能。总体的思路是source -> transform -> sink，即从source获取相应的数据来源，然后进行数据转换，将数据从比较乱的格式，转换成我们需要的格式，转换处理后，然后进行sink功能，也就是将数据写入到相应的db里边 阅读详情

一、需求背景概述

由于公司业务需要将kafka的数据写入到hologres中，但是发现flinksql那种简便的方式会各种报错(很有可能是我包引用的不对，但是找了阿里支持也没有解决)，无奈只能使用flink-core进行编写。当然，代码并没有那么完美，方法也不一定是最优，有小伙伴有更好的方法和实践经验的话欢迎交流。

二、pom依赖

由于公司使用的版本是flink1.11且项目中还有别的代码，所以pom文件中会有多余的依赖，大家可以根据实际情况各取所需，至少这份代码使用下面的依赖没有发生冲突或者错误。

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>******</groupId>
    <artifactId>******</artifactId>
    <version>1.0-SNAPSHOT</version>


    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <scala.binary.version>2.11.8</scala.binary.version>
        <jdk.compile.version>1.8</jdk.compile.version>
        <flink.version>1.11.3</flink.version>
        <maven.version>3.3.3</maven.version>
        <hadoop.version>2.8.4</hadoop.version>
        <hbase.version>2.2.0</hbase.version>
        <hologres.client.version>2.1.1</hologres.client.version>
    </properties>

    <dependencies>

        <dependency>
            <groupId>org.scala-lang</groupId>
            <artifactId>scala-library</artifactId>
            <version>2.11.8</version>
        </dependency>

        <dependency>
            <groupId>org.scala-lang</groupId>
            <artifactId>scala-compiler</artifactId>
            <version>2.11.8</version>
        </dependency>
        <!-- flink start -->
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-clients_2.11</artifactId>
            <version>${flink.version}</version>
            <exclusions>
                <exclusion>
                    <groupId>org.apache.flink</groupId>
                    <artifactId>flink-streaming-java_2.11</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-core</artifactId>
            <version>${flink.version}</version>
        </dependency>

        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-scala_2.11</artifactId>
            <version>${flink.version}</version>
        </dependency>

        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-java</artifactId>
            <version>${flink.version}</version>
        </dependency>

        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-streaming-scala_2.11</artifactId>
            <version>${flink.version}</version>
            <exclusions>
                <exclusion>
                    <groupId>org.apache.flink</groupId>
                    <artifactId>flink-streaming-java_2.11</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-streaming-java_2.11</artifactId>
            <version>1.11.3</version>
        </dependency>

        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-connector-kafka-0.10_2.11</artifactId>
            <version>${flink.version}</version>
        </dependency>

        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-statebackend-rocksdb_2.11</artifactId>
            <version>${flink.version}</version>
        </dependency>

        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-table-planner-blink_2.11</artifactId>
            <version>${flink.version}</version>
            <scope>provided</scope>
        </dependency>

        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-table-api-scala-bridge_2.11</artifactId>
            <version>${flink.version}</version>
            <scope>provided</scope>
        </dependency>

        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-table-api-java-bridge_2.11</artifactId>
            <version>${flink.version}</version>
            <scope>provided</scope>
        </dependency>

        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-json</artifactId>
            <version>${flink.version}</version>
        </dependency>

        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-connector-jdbc_2.11</artifactId>
            <version>${flink.version}</version>
        </dependency>
        
		<dependency>
            <groupId>com.alibaba.hologres</groupId>
            <artifactId>hologres-connector-flink-1.11</artifactId>
            <version>1.0.0</version>
        </dependency>

        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-table-common</artifactId>
            <version>${flink.version}</version>
            <scope>provided</scope>
        </dependency>
        
        <!-- flink end -->

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.73</version>
        </dependency>

        <dependency>
            <groupId>com.typesafe</groupId>
            <artifactId>config</artifactId>
            <version>1.3.3</version>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.6</version>
        </dependency>

        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>4.5.2</version>
        </dependency>

        <dependency>
            <groupId>com.zaxxer</groupId>
            <artifactId>HikariCP</artifactId>
            <version>3.4.5</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.30</version>
        </dependency>

        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-simple</artifactId>
            <version>1.7.25</version>
            <scope>compile</scope>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.6</version>
        </dependency>

        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-simple</artifactId>
            <version>1.7.25</version>
            <scope>compile</scope>
        </dependency>

        <!-- https://mvnrepository.com/artifact/com.google.code.gson/gson -->
        <dependency>
            <groupId>com.google.code.gson</groupId>
            <artifactId>gson</artifactId>
            <version>2.8.5</version>
        </dependency>

    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.scala-tools</groupId>
                <artifactId>maven-scala-plugin</artifactId>
                <version>2.15.2</version>
                <executions>
                    <execution>
                        <id>scala-compile-first</id>
                        <goals>
                            <goal>compile</goal>
                        </goals>
                        <configuration>
                            <includes>
                                <include>**/*.scala</include>
                                <include>**/*.java</include>
                            </includes>
                        </configuration>
                    </execution>
                    <execution>
                        <id>scala-test-compile</id>
                        <goals>
                            <goal>testCompile</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>3.1.1</version>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                        <configuration>
                            <artifactSet>
                                <excludes>
                                    <exclude>com.google.code.findbugs:jsr305</exclude>
                                    <exclude>org.slf4j:*</exclude>
                                    <exclude>log4j:*</exclude>
                                </excludes>
                            </artifactSet>
                            <filters>
                                <filter>
                                    <!-- Do not copy the signatures in the META-INF folder.
                                    Otherwise, this might cause SecurityExceptions when using the JAR. -->
                                    <artifact>*:*</artifact>
                                    <excludes>
                                        <exclude>META-INF/*.SF</exclude>
                                        <exclude>META-INF/*.DSA</exclude>
                                        <exclude>META-INF/*.RSA</exclude>
                                    </excludes>
                                </filter>
                            </filters>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>

三、代码实现

为了方便我把所有代码放到了一起，这样也方便查找，当然了，关键的信息我会隐去，大家可以根据自己的情况替换成自己的配置。(在代码中其实需要将kafka的数据进行转换然后写到holo)

代码依赖

在看别的博客的时候有时候发现有的没有依赖包，尤其在比较着急看成效的时候还挺麻烦的，所以为了方便自己和大家，我把import信息也加上。

import com.alibaba.fastjson.JSON;
import com.alibaba.ververica.connectors.hologres.api.HologresTableSchema;
import com.alibaba.ververica.connectors.hologres.config.HologresConnectionParam;
import org.apache.flink.api.common.serialization.DeserializationSchema;
import org.apache.flink.api.common.typeinfo.TypeInformation;
import org.apache.flink.configuration.Configuration;
import org.apache.flink.runtime.state.filesystem.FsStateBackend;
import org.apache.flink.streaming.api.CheckpointingMode;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.environment.CheckpointConfig;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import com.alibaba.hologres.client.model.Record;
import com.alibaba.ververica.connectors.hologres.api.HologresRecordConverter;
import com.alibaba.ververica.connectors.hologres.config.HologresConfigs;
import com.alibaba.ververica.connectors.hologres.jdbc.HologresJDBCWriter;
import com.alibaba.ververica.connectors.hologres.sink.HologresOutputFormat;
import org.apache.flink.streaming.api.functions.sink.OutputFormatSinkFunction;
import org.apache.flink.streaming.connectors.kafka.FlinkKafkaConsumer010;
import org.apache.flink.table.api.DataTypes;
import org.apache.flink.table.api.TableSchema;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.CharBuffer;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.text.SimpleDateFormat;
import java.util.Map;
import java.util.Properties;

正式代码

public class sensorLog2holo {

    public static void main(String[] args) {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        env.setStateBackend(new FsStateBackend("checkpoint地址"));
        env.enableCheckpointing(5000);
        env.getCheckpointConfig().setCheckpointingMode(CheckpointingMode.EXACTLY_ONCE);
        env.getCheckpointConfig().setMinPauseBetweenCheckpoints(500);
        env.getCheckpointConfig().setCheckpointTimeout(60000);
        env.getCheckpointConfig().setMaxConcurrentCheckpoints(1);
        env.getCheckpointConfig().enableExternalizedCheckpoints(CheckpointConfig.ExternalizedCheckpointCleanup.RETAIN_ON_CANCELLATION);

        //kafka配置文件
        Properties properties = new Properties();
        properties.setProperty("bootstrap.servers", "******");
        properties.setProperty("group.id", "******");
        properties.setProperty("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        properties.setProperty("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        properties.setProperty("auto.offset.reset", "******");

        DataStreamSource<SensorLog> kafkaSource =
                env.addSource(new FlinkKafkaConsumer010<SensorLog>("topic name", new SensorLogSerializer(), properties));


        //holo配置
        Configuration configuration = new Configuration();
        configuration.set(HologresConfigs.ENDPOINT, "******");
        configuration.set(HologresConfigs.DATABASE, "******");
        configuration.set(HologresConfigs.USERNAME, "******");
        configuration.set(HologresConfigs.PASSWORD, ""******");");
        configuration.set(HologresConfigs.TABLE, "schema名称.表名");
        HologresConnectionParam hologresConnectionParam = new HologresConnectionParam(configuration);

        /*
        *目标表table schema，下面是示例
        */
        TableSchema schema =
                TableSchema.builder()
                        .field("event", DataTypes.STRING())
                        .field("distinct_id", DataTypes.STRING())
                        .field("appname", DataTypes.STRING())
                        .build();

        kafkaSource.addSink(
                new OutputFormatSinkFunction<SensorLog>(
                        new HologresOutputFormat<>(
                                hologresConnectionParam,
                                new HologresJDBCWriter<>(
                                        hologresConnectionParam,
                                        schema,
                                        new RecordConverter(hologresConnectionParam)))));

       env.execute("sensorLog2holo");

    }


    /**
     * 将用户POJO数据转换至Hologres Record的实现.
     */
    public static class RecordConverter implements HologresRecordConverter<SensorLog, Record> {
        private HologresConnectionParam hologresConnectionParam;
        private HologresTableSchema tableSchema;

        public RecordConverter(HologresConnectionParam hologresConnectionParam) {
            this.hologresConnectionParam = hologresConnectionParam;
        }

        @Override
        public Record convertFrom(SensorLog record) {
            if (tableSchema == null) {
                this.tableSchema =
                        HologresTableSchema.get(hologresConnectionParam.getJdbcOptions());
            }
            Record result = new Record(tableSchema.get());
            result.setObject(0, record.getEvent());
            result.setObject(1, record.getDistinct_id());
            result.setObject(3, record.getProperties().get("appname"));
            return result;
        }

        @Override
        public SensorLog convertTo(Record record) {
            throw new UnsupportedOperationException("No need to implement");
        }

        @Override
        public Record convertToPrimaryKey(SensorLog record) {
            throw new UnsupportedOperationException("No need to implement");
        }
    }

    /**
     * 自定义序列化
     */
    static class SensorLogSerializer implements DeserializationSchema<SensorLog> {
        private static final long serialVersionUID = 1L;

        @Override
        public SensorLog deserialize(byte[] message) throws IOException {
            ByteBuffer buffer = ByteBuffer.wrap(message).order(ByteOrder.LITTLE_ENDIAN);

            String mess = this.byteBuffertoString(buffer);
            //封装为POJO类
            SensorLog sensorLog = JSON.parseObject(mess, SensorLog.class);
            return sensorLog;
        }

        @Override
        public boolean isEndOfStream(SensorLog nextElement) {
            return false;
        }

        @Override
        public TypeInformation<SensorLog> getProducedType() {
            return TypeInformation.of(SensorLog.class);
        }

        /**
         * 将ByteBuffer类型转换为String类型
         *
         * @param buffer
         * @return
         */
        static public String byteBuffertoString(ByteBuffer buffer) {
            Charset charset = null;
            CharsetDecoder decoder = null;
            CharBuffer charBuffer = null;
            try {
                charset = Charset.forName("UTF-8");
                decoder = charset.newDecoder();
                charBuffer = decoder.decode(buffer.asReadOnlyBuffer());
                return charBuffer.toString();
            } catch (Exception ex) {
                ex.printStackTrace();
                return "";
            }
        }
    }


    /*
    *kafka数据对应的实体类，需要有getter&setter
    */
    static class SensorLog {
        *****
    }
}
收录于
flink

当前文章被收录于：

flink
1 篇文章 1 人学习

flink

订阅专栏 查看详情
标签
#java #kafka #flink
本内容遵循 CC 4.0 BY-SA 版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
Flink消费kafka消息实战，java面试题基础知识 说句实话，如果一个打工人不想提升自己，那便没有工作的意义，毕竟大家也没有到养老的年龄。当你的技术在一步步贴近阿里p7水平的时候，毫无疑问你的薪资肯定会涨，同时你能学到更多更深的技术，交结到更厉害的大牛。推荐一份Java架构之路必备的学习笔记，内容相当全面！！！成年人的世界没有容易二字，前段时间刷抖音看到一个程序员连着加班两星期到半夜2点的视频。在这个行业若想要拿高薪除了提高硬实力别无他法。你知道吗？现在有的应届生实习薪资都已经赶超开发5年的程序员了，实习薪资26K，30K，你没有紧迫感吗？ 阅读详情

相关推荐

37手游云平台基于Flink+Hologres大数据建设实践

本文介绍37手游云平台基于Flink+Hologres大数据建设实践

aliyunhologres的博客 2633

使用Java开发案例：Flink消费Kafka消息

在项目中添加Flink的依赖项，以便我们可以使用Flink的功能。在本篇文章中，我将为您介绍如何使用Apache Flink框架来开发Java项目，以消费Kafka消息。这样，您就成功地使用Java开发了一个Flink作业，用于消费Kafka消息。该作业将从指定的Kafka主题中消费消息，并将其打印到控制台上。首先，确保您已经安装了Java开发环境和Apache Flink框架，并且已经设置好了Kafka集群。然后，我们设置了Kafka的相关配置，包括Kafka的地址和消费者组ID。方法打印接收到的消息。

DeoSql的博客 310

java工程_impala同步到hologres

很久没碰过java工程了，安装IDEA，下载JDK、Maven，遇到一些问题，阿伟帮着看问题，欣喜回想起自己之前写过关于Maven的博客，对自己还是有用的，和阿伟通力解决了pom.xml的问题。博客链接是：掌握maven 1、如何下载安装Maven，参考：Maven下载及安装 遇到的问题： 1.1、pom.xml 报错 ：Failed to read artifact descriptor for org.glassfish:javax.el:jar:3.0.1-b06-SNAPSHOT 如何解决：可看到

AnlaGodness的博客 559

【信息科学与工程学】【数据中心】第三十五篇 云计算数据中心的学科知识04

编号学科（课程）核心知识点在云计算/云存储/云网络/云安全/云MaaS中的作用代表教材/资料/论文 + 数学方程式列表工业界应用D1421​云原生数据库：TiDB​HTAP（混合事务/分析处理）、分布式SQL、水平扩展、强一致（Raft）、自动故障恢复、与MySQL兼容、TiFlash列式引擎提供弹性扩展的分布式数据库；支撑高并发在线交易与实时分析教材：《TiDB in Action》PingCAP（2020） 论文：《TiDB: A Raft-based HTAP Database》（2017）

weixin_49199313的博客 157

实时计算Flink+Hologres

对于主键关联的场景（即 Join 条件分别是两条流的主键），我们可以将 Join 的工作下沉到 Hologres 去做，通过 Hologres 的局部更新功能来实现宽表 Merge，从而省去了 Flink Join 的状态维护成本。数据实时入仓形成了 ODS 层的数据后，通常需要将事实数据与维度数据利用 Flink 多流 Join 的能力实时地打平成宽表，结合 Hologres 宽表极佳的多维分析性能，助力上层业务查询提速。目前该方案已在阿里巴巴内部、众多云上企业生产落地，成为实时数仓的最佳解决方案之一。

song_quan_的博客 3356

flink sql 如何upsert 到一张hologres表中

Flink Table Sink 的三种模式本质上是如何监控结果表并产生 changelog，这可以应用于所有需要将表转为流的场景，包括同一个 Flink 应用的不同表间的联动。三种模式中 Append 模式只支持表的INSERT，最为简单；Upsert 模式依赖业务主键提供INSERTUPDATE和DELETE全部三类变更，比较实用；Retract 模式同样支持三类变更且不要求业务主键，但会将UPDATE翻译为旧数据的撤回和新数据的累加，实现上比较复杂。

m0_38109926的博客 1749

Hologres 连接器开发指南

Hologres 连接器开发指南 一、项目介绍 Hologres 是阿里云提供的一款端对端实时数据仓库服务, 它支持大规模数据的实时写入、更新和分析能力, 并且兼容 PostgreSQL 协议, 支持标准SQL语法。Hologres还具备在线分析处理(OLAP)能力和即席查询的能力。 alibabacloud-hologres-connectors项目旨在集成Hologres与其他大数据平台和服务...

gitblog_00232的博客 1110

flink + kafka 同步binlog的一次关于数据顺序的实践

场景说明 ​ 业务部门的Mysql数据使用阿里DTS（数据传输工具）上报了binlog日志。对于数仓部门有两个需求 从DTS将数据，只保留type(insert，delete，update)跟record到kafka方便多方消费； 为了验证Kafka准确性，数仓部门也消费kafka数据落地到Hologres，对比hologres与mysql原表保证完全一致。 问题 DTS端并行度为1，但是ETL过程因为下游算子有多个并行度，有可能出现数据乱序（DTS->Kafka乱序） 消费Kafka的时候由

dinl_vin的博客 2526

Hologres：高性能实时数据分析引擎

Hologres: 是由阿里巴巴推出的一款云原生的高性能实时数据分析引擎，专注于处理大规模数据的实时分析和查询。

技术研究中心 840

大数据-玩转数据-Flink+Hologres构建实时数仓

随着大数据的迅猛发展，企业越来越重视数据的价值，这就意味着需要数据尽快到达企业分析决策人员，以最大化发挥数据价值。企业最常见的做法就是通过构建实时数仓来满足对数据的快速探索。在业务建设过程中，实时数仓需要支持数据实时写入与更新、业务敏捷快速响应、数据自助分析、运维操作便捷、云原生弹性扩缩容等一系列需求，而这就依赖一个强大的实时数仓解决方案。阿里云实时计算 Flink 版（以下简称“阿里云 Flink”）提供全增量一体化数据同步技术、强大的流式 ETL 等能力，支持海量数据实时入仓入湖。阿里云 Hologre

s_unbo的博客 3245

实战Flink Java api消费kafka实时数据落盘HDFS

在Java api中，使用flink本地模式，消费kafka主题，并直接将数据存入hdfs中。

qq_31412425的博客 2632

Flink+Hologres实时数据仓库架构说明

在 Flink和 Hologres结合的架构中，Hologres提供了高效的数据存储和检索能力，这是这个架构能够快速处理数据的重要原因之一。当 Flink从 Hologres中读取数据时，Hologres提供了强大的数据检索能力，使得 Spark 能够以更快的速度读取数据，并且可以快速地对数据进行计算和处理。因此，Hologres提供了高效的数据存储和检索能力，为 Flink提供了一个优秀的数据源，从而使得整个数据处理流程更加高效和快速。这种架构的设计能够有效地提高数据处理的效率和性能。补充。

wangbowen2000的博客 1475

java 查询 hologres，对holo查询语句控制

holo查询控制查询时长

weixin_38285470的博客 546

Java-Druid数据库连接池的基本使用及解决Java连接数据库连接池Druid时报错问题

Java-Druid数据库连接池的基本使用及Client does not support authentication protocol requested by server; consider upgrading MySQL client及Unknown initial character set index '255' received from server. Initial client character set can be forced via the 'characterEncoding

weixin_63930192的博客 1559

java 查询 hologres，对holo查询语句控制（优化版）

加优化版是因为上一版本会存在sql注入风险，所以做了一点优化。大体不变，改动较小，其他的和之前版本一致。

weixin_38285470的博客 456

kafka数据写入hologres

kafka数据写入hologres

Sukang1920的博客 314

Hologres&Flink搭建数仓

如果存的是自己的mysql就可以用Flink CDC同步过来原始数据存在RDS中把数据读取后先放入数据总线中DataHub作为原始数据存储(也可以放kafka)

u014474768的博客 1600

解锁阿里云Hologres：开启实时数据分析新时代

Hologres 是阿里云自主研发推出的一款全托管的 PB 级实时交互式分析服务，堪称大数据领域的 “超级引擎”。它诞生于大数据量爆发式增长和企业对实时数据分析需求急剧攀升的时代背景下。在过去，传统的数据处理和分析架构在面对海量数据时，往往显得力不从心，难以满足企业对数据实时性、分析效率以及扩展性的严苛要求。例如，传统的数据仓库在处理实时数据时存在较大延迟，无法及时为企业决策提供支持；而一些实时流处理框架虽然能处理数据的实时流入，但在复杂数据分析和查询方面又存在短板。

阿里云_腾讯云_华为云_优惠政策_技术支持 1430
上一篇： anaconda使用国内数据源
点赞 0
评论 1
书签 书签 0
moshang_find
moshang_find
博客等级 码龄10年 30粉丝 67原创
+ 关注 专栏目录 订阅专栏
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值