大数据技术——DataX配置文件生成器

于 2024-08-10 13:32:35 发布
阅读量346 收藏 4
点赞数 3
分类专栏： hadoop 文章标签： 大数据 python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_63106307/article/details/141089612
版权

目录

一、代码

1.1 新建Maven项目

1.3 新建com.atguigu.datax.beans.Column类

1.4  新建com.atguigu.datax.beans.Table类

1.5 新建com.atguigu.datax.configuration.Configuration类

1.6  ​​​​​​​新建com.atguigu.datax.helper.DataxJsonHelper类

1.7 ​​​​​​​新建com.atguigu.datax.helper.MysqlHelper类

1.8 ​​​​​​​新建com.atguigu.datax.Main类

二、如何使用

2.1 ​​​​​​ 修改配置文件

2.2 运行

一、代码

1.1 新建Maven项目

1.2 添加如下依赖

<properties>	
    <maven.compiler.source>8</maven.compiler.source>
    <maven.compiler.target>8</maven.compiler.target>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>

<dependencies>
    <dependency>
        <groupId>cn.hutool</groupId>
        <artifactId>hutool-json</artifactId>
        <version>5.8.11</version>
    </dependency>
    <dependency>
        <groupId>cn.hutool</groupId>
        <artifactId>hutool-db</artifactId>
        <version>5.8.11</version>
    </dependency>
    <dependency>
        <groupId>com.mysql</groupId>
        <artifactId>mysql-connector-j</artifactId>
        <version>8.0.31</version>
    </dependency>
</dependencies>
<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-assembly-plugin</artifactId>
            <version>3.3.0</version>
            <configuration>
                <!--指定jar包的入口类，UDF用不到主类，因此不用指定-->
                <archive>
                    <manifest>
                        <mainClass>com.atguigu.datax.Main</mainClass>
                    </manifest>
                </archive>
                <!--将依赖编译到jar包中-->
                <descriptorRefs>
                    <descriptorRef>jar-with-dependencies</descriptorRef>
                </descriptorRefs>
            </configuration>
            <executions>
                <!--配置执行器-->
                <execution>
                    <id>make-assembly</id>
                    <!--绑定到package执行周期上-->
                    <phase>package</phase>
                    <goals>
                        <!--只运行一次-->
                        <goal>single</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

1.3 新建com.atguigu.datax.beans.Column类

package com.atguigu.datax.beans;

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

public class Column {
    private final String name;
    private final String type;
    private final String hiveType;
    private static final Map<String, String> typeMap = new HashMap<>();

    static {
        typeMap.put("bigint", "bigint");
        typeMap.put("int", "bigint");
        typeMap.put("smallint", "bigint");
        typeMap.put("tinyint", "bigint");
        typeMap.put("double", "double");
        typeMap.put("float", "float");
    }

    public Column(String name, String type) {
        this.name = name;
        this.type = type;
        this.hiveType = typeMap.getOrDefault(type, "string");
    }

    public String name() {
        return name;
    }

    public String type() {
        return type;
    }

    public String hiveType() {
        return hiveType;
    }
}

1.4  新建com.atguigu.datax.beans.Table类

package com.atguigu.datax.beans;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class Table {
    private final String tableName;
    private final List<Column> columns;

    public Table(String tableName) {
        this.tableName = tableName;
        this.columns = new ArrayList<>();

    }

    public String name() {
        return tableName;
    }

    public void addColumn(String name, String type) {
        columns.add(new Column(name, type));
    }

    public List<String> getColumnNames() {
        return columns.stream().map(Column::name).collect(Collectors.toList());
    }

    public List<Map<String, String>> getColumnNamesAndTypes() {
        List<Map<String, String>> result = new ArrayList<>();
        columns.forEach(column -> {
            Map<String, String> temp = new HashMap<>();
            temp.put("name", column.name());
            temp.put("type", column.hiveType());
            result.add(temp);
        });
        return result;
    }
}

1.5 ​​​​​​​新建com.atguigu.datax.configuration.Configuration类

package com.atguigu.datax.configuration;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Properties;

public class Configuration {
    public static String MYSQL_USER;
    public static String MYSQL_PASSWORD;
    public static String MYSQL_HOST;
    public static String MYSQL_PORT;
    public static String MYSQL_DATABASE_IMPORT;
    public static String MYSQL_DATABASE_EXPORT;
    public static String MYSQL_URL_IMPORT;
    public static String MYSQL_URL_EXPORT;
    public static String MYSQL_TABLES_IMPORT;
    public static String MYSQL_TABLES_EXPORT;
    public static String IS_SEPERATED_TABLES;
    public static String HDFS_URI;
    public static String IMPORT_OUT_DIR;
    public static String EXPORT_OUT_DIR;
    public static String IMPORT_MIGRATION_TYPE = "import";
    public static String EXPORT_MIGRATION_TYPE = "export";

    static {
        Path path = Paths.get("configuration.properties");
        Properties configuration = new Properties();
        try {
            configuration.load(Files.newBufferedReader(path));
            MYSQL_USER = configuration.getProperty("mysql.username", "root");
            MYSQL_PASSWORD = configuration.getProperty("mysql.password", "000000");
            MYSQL_HOST = configuration.getProperty("mysql.host", "hadoop102");
            MYSQL_PORT = configuration.getProperty("mysql.port", "3306");
            MYSQL_DATABASE_IMPORT = configuration.getProperty("mysql.database.import", "ad");
            MYSQL_DATABASE_EXPORT = configuration.getProperty("mysql.database.export", "ad_report");
            MYSQL_URL_IMPORT = "jdbc:mysql://" + MYSQL_HOST + ":" + MYSQL_PORT + "/" + MYSQL_DATABASE_IMPORT + "?useSSL=false&allowPublicKeyRetrieval=true&useUnicode=true&characterEncoding=utf-8";
            MYSQL_URL_EXPORT = "jdbc:mysql://" + MYSQL_HOST + ":" + MYSQL_PORT + "/" + MYSQL_DATABASE_EXPORT + "?useSSL=false&allowPublicKeyRetrieval=true&useUnicode=true&characterEncoding=utf-8";
            MYSQL_TABLES_IMPORT = configuration.getProperty("mysql.tables.import", "");
            MYSQL_TABLES_EXPORT = configuration.getProperty("mysql.tables.export", "");
            IS_SEPERATED_TABLES = configuration.getProperty("is.seperated.tables", "0");
            HDFS_URI = configuration.getProperty("hdfs.uri", "hdfs://hadoop102:8020");
            IMPORT_OUT_DIR = configuration.getProperty("import_out_dir");
            EXPORT_OUT_DIR = configuration.getProperty("export_out_dir");
        } catch (IOException e) {
            MYSQL_USER = "root";
            MYSQL_PASSWORD = "000000";
            MYSQL_HOST = "hadoop102";
            MYSQL_PORT = "3306";
            MYSQL_DATABASE_IMPORT = "ad";
            MYSQL_DATABASE_EXPORT = "ad_report";
            MYSQL_URL_IMPORT = "jdbc:mysql://" + MYSQL_HOST + ":" + MYSQL_PORT + "/" + MYSQL_DATABASE_IMPORT + "?useSSL=false&allowPublicKeyRetrieval=true&useUnicode=true&characterEncoding=utf-8";
            MYSQL_URL_EXPORT = "jdbc:mysql://" + MYSQL_HOST + ":" + MYSQL_PORT + "/" + MYSQL_DATABASE_EXPORT + "?useSSL=false&allowPublicKeyRetrieval=true&useUnicode=true&characterEncoding=utf-8";
            MYSQL_TABLES_IMPORT = "";
            MYSQL_TABLES_EXPORT = "";
            IS_SEPERATED_TABLES = "0";
            HDFS_URI = "hdfs://hadoop102:8020";
            IMPORT_OUT_DIR = null;
            EXPORT_OUT_DIR = null;
        }
    }

    public static void main(String[] args) {
        System.out.println(MYSQL_DATABASE_EXPORT);
    }
}

1.6  ​​​​​​​新建com.atguigu.datax.helper.DataxJsonHelper类

package com.atguigu.datax.helper;

import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import com.atguigu.datax.beans.Table;
import com.atguigu.datax.configuration.Configuration;

public class DataxJsonHelper {

    // 解析 inputConfig 和 outputConfig 模板

    // Hadoop 单点集群
    private final JSONObject inputConfig = JSONUtil.parseObj("{\"job\":{\"content\":[{\"reader\":{\"name\":\"mysqlreader\",\"parameter\":{\"column\":[],\"connection\":[{\"jdbcUrl\":[],\"table\":[]}],\"password\":\"\",\"splitPk\":\"\",\"username\":\"\"}},\"writer\":{\"name\":\"hdfswriter\",\"parameter\":{\"column\":[],\"compress\":\"gzip\",\"defaultFS\":\"\",\"fieldDelimiter\":\"\\t\",\"fileName\":\"content\",\"fileType\":\"text\",\"path\":\"${targetdir}\",\"writeMode\":\"truncate\",\"nullFormat\":\"\"}}}],\"setting\":{\"speed\":{\"channel\":1}}}}");
    private final JSONObject outputConfig = JSONUtil.parseObj("{\"job\":{\"setting\":{\"speed\":{\"channel\":1}},\"content\":[{\"reader\":{\"name\":\"hdfsreader\",\"parameter\":{\"path\":\"${exportdir}\",\"defaultFS\":\"\",\"column\":[\"*\"],\"fileType\":\"text\",\"encoding\":\"UTF-8\",\"fieldDelimiter\":\"\\t\",\"nullFormat\":\"\\\\N\"}},\"writer\":{\"name\":\"mysqlwriter\",\"parameter\":{\"writeMode\":\"replace\",\"username\":\"\",\"password\":\"\",\"column\":[],\"connection\":[{\"jdbcUrl\":\"\",\"table\":[]}]}}}]}}");

    // Hadoop HA 集群
//    private final JSONObject inputConfig = JSONUtil.parseObj("{\"job\": {\"content\": [{\"reader\": {\"name\": \"mysqlreader\",\"parameter\": {\"column\": [],\"connection\": [{\"jdbcUrl\": [],\"table\": []}],\"password\": \"\",\"splitPk\": \"\",\"username\": \"\"}},\"writer\": {\"name\": \"hdfswriter\",\"parameter\": {\"column\": [],\"compress\": \"gzip\",\"defaultFS\": \"hdfs://mycluster\",\"dfs.nameservices\": \"mycluster\",\"dfs.ha.namenodes.mycluster\": \"namenode1,namenode2\",\"dfs.namenode.rpc-address.aliDfs.namenode1\": \"hdfs://hadoop102:8020\",\"dfs.namenode.rpc-address.aliDfs.namenode2\": \"hdfs://hadoop103:8020\",\"dfs.client.failover.proxy.provider.mycluster\": \"org.apache.hadoop.hdfs.server.namenode.ha.ConfiguredFailoverProxyProvider\",\"fieldDelimiter\": \"\\t\",\"fileName\": \"content\",\"fileType\": \"text\",\"path\": \"${targetdir}\",\"writeMode\": \"truncate\",\"nullFormat\": \"\"}}}],\"setting\": {\"speed\": {\"channel\": 1}}}}");
//    private final JSONObject outputConfig = JSONUtil.parseObj("{\"job\": {\"setting\": {\"speed\": {\"channel\": 1}},\"content\": [{\"reader\": {\"name\": \"hdfsreader\",\"parameter\": {\"path\": \"${exportdir}\",\"defaultFS\": \"\",\"dfs.nameservices\": \"mycluster\",\"dfs.ha.namenodes.mycluster\": \"namenode1,namenode2\",\"dfs.namenode.rpc-address.aliDfs.namenode1\": \"hdfs://hadoop102:8020\",\"dfs.namenode.rpc-address.aliDfs.namenode2\": \"hdfs://hadoop103:8020\",\"dfs.client.failover.proxy.provider.mycluster\": \"org.apache.hadoop.hdfs.server.namenode.ha.ConfiguredFailoverProxyProvider\",\"column\": [\"*\"],\"fileType\": \"text\",\"encoding\": \"UTF-8\",\"fieldDelimiter\": \"\\t\",\"nullFormat\": \"\\\\N\"}},\"writer\": {\"name\": \"mysqlwriter\",\"parameter\": {\"writeMode\": \"replace\",\"username\": \"\",\"password\": \"\",\"column\": [],\"connection\": [{\"jdbcUrl\": [],\"table\": []}]}}}]}}");

    public DataxJsonHelper() {
        // 获取 Reader 和 Writer 配置
        JSONObject mysqlReaderPara = inputConfig.getByPath("job.content[0].reader.parameter", JSONObject.class);
        JSONObject hdfsWriterPara = inputConfig.getByPath("job.content[0].writer.parameter", JSONObject.class);
        JSONObject hdfsReaderPara = outputConfig.getByPath("job.content[0].reader.parameter", JSONObject.class);
        JSONObject mysqlWriterPara = outputConfig.getByPath("job.content[0].writer.parameter", JSONObject.class);

        // 设置 DefaultFS
        hdfsReaderPara.set("defaultFS", Configuration.HDFS_URI);
        hdfsWriterPara.set("defaultFS", Configuration.HDFS_URI);

        // 设置 MySQL Username
        mysqlReaderPara.set("username", Configuration.MYSQL_USER);
        mysqlWriterPara.set("username", Configuration.MYSQL_USER);

        // 设置 MySQL Password
        mysqlReaderPara.set("password", Configuration.MYSQL_PASSWORD);
        mysqlWriterPara.set("password", Configuration.MYSQL_PASSWORD);

        // 设置 JDBC URL
        mysqlReaderPara.putByPath("connection[0].jdbcUrl[0]", Configuration.MYSQL_URL_IMPORT);
        mysqlWriterPara.putByPath("connection[0].jdbcUrl", Configuration.MYSQL_URL_EXPORT);

        // 写回Reader和Writer配置
        inputConfig.putByPath("job.content[0].reader.parameter", mysqlReaderPara);
        inputConfig.putByPath("job.content[0].writer.parameter", hdfsWriterPara);
        outputConfig.putByPath("job.content[0].reader.parameter", hdfsReaderPara);
        outputConfig.putByPath("job.content[0].writer.parameter", mysqlWriterPara);
    }

    public void setTableAndColumns(Table table, int index, String migrationType) {
        // 设置表名
        setTable(table, index, migrationType);
        // 设置列名及路径
        setColumns(table, migrationType);
    }

    public void setColumns(Table table, String migrationType) {
        if (migrationType.equals("import")) {
            // 设置 hdfswriter 文件名
            inputConfig.putByPath("job.content[0].writer.parameter.fileName", table.name());
            // 设置列名
            inputConfig.putByPath("job.content[0].reader.parameter.column", table.getColumnNames());
            inputConfig.putByPath("job.content[0].writer.parameter.column", table.getColumnNamesAndTypes());
        } else {
            // 设置列名
            outputConfig.putByPath("job.content[0].writer.parameter.column", table.getColumnNames());
        }
    }

    public void setTable(Table table, int index, String migrationType) {
        if (migrationType.equals("import")) {
            // 设置表名
            inputConfig.putByPath("job.content[0].reader.parameter.connection[0].table[" + index + "]", table.name());
        } else {
            outputConfig.putByPath("job.content[0].writer.parameter.connection[0].table[" + index + "]", table.name());
        }
    }

    public JSONObject getInputConfig() {
        return inputConfig;

    }

    public JSONObject getOutputConfig() {
        return outputConfig;
    }
}

1.7 ​​​​​​​新建com.atguigu.datax.helper.MysqlHelper类

package com.atguigu.datax.helper;

import cn.hutool.db.Db;
import cn.hutool.db.Entity;
import cn.hutool.db.ds.DSFactory;
import cn.hutool.setting.Setting;
import com.atguigu.datax.beans.Table;
import com.atguigu.datax.configuration.Configuration;

import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

public class MysqlHelper {
    private final List<Table> tables;

    public List<Table> getTables() {
        return tables;
    }

    public MysqlHelper(String url, String database, String mysqlTables) {
        tables = new ArrayList<>();

        Db db = Db.use(DSFactory.create(
                Setting.create()
                        .set("url", url)
                        .set("user", Configuration.MYSQL_USER)
                        .set("pass", Configuration.MYSQL_PASSWORD)
                        .set("showSql", "false")
                        .set("showParams", "false")
                        .set("sqlLevel", "info")
        ).getDataSource());

        // 获取设置的表格，如未设置，查询数据库下面所有表格
        if (mysqlTables != null && !"".equals(mysqlTables)) {
            for (String mysqlTable : mysqlTables.split(",")) {
                tables.add(new Table(mysqlTable));
            }
        } else {
            try {
                db.findAll(Entity.create("information_schema.TABLES")
                                .set("TABLE_SCHEMA", database))
                        .forEach(entity ->
                                tables.add(new Table(entity.getStr("TABLE_NAME"))));
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
        }


        // 获取所有表格的列
        for (Table table : tables) {
            try {
                db.findAll(Entity.create("information_schema.COLUMNS")
                                .set("TABLE_SCHEMA", database)
                                .set("TABLE_NAME", table.name())
                        ).stream()
                        .sorted(Comparator.comparingInt(o -> o.getInt("ORDINAL_POSITION")))
                        .forEach(entity -> table.addColumn(
                                entity.getStr("COLUMN_NAME"),
                                entity.getStr("DATA_TYPE")
                        ));
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

1.8 ​​​​​​​新建com.atguigu.datax.Main类

package com.atguigu.datax;

import cn.hutool.json.JSONUtil;
import com.atguigu.datax.beans.Table;
import com.atguigu.datax.configuration.Configuration;
import com.atguigu.datax.helper.DataxJsonHelper;
import com.atguigu.datax.helper.MysqlHelper;

import java.io.FileWriter;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.List;

public class Main {
    public static void main(String[] args) throws IOException {

        // 生成 HDFS 入方向配置文件
        if (Configuration.IMPORT_OUT_DIR != null &&
                !Configuration.IMPORT_OUT_DIR.equals("")) {
            MysqlHelper mysqlHelper = new MysqlHelper(
                    Configuration.MYSQL_URL_IMPORT,
                    Configuration.MYSQL_DATABASE_IMPORT,
                    Configuration.MYSQL_TABLES_IMPORT);
            DataxJsonHelper dataxJsonHelper = new DataxJsonHelper();

            // 获取迁移操作类型
            String migrationType = Configuration.IMPORT_MIGRATION_TYPE;

            // 创建父文件夹
            Files.createDirectories(Paths.get(Configuration.IMPORT_OUT_DIR));
            List<Table> tables = mysqlHelper.getTables();

            // 判断传入的表是否为分表，根据判断结果采用不同的处理策略
            if (Configuration.IS_SEPERATED_TABLES.equals("1")) {
                for (int i = 0; i < tables.size(); i++) {
                    Table table = tables.get(i);
                    dataxJsonHelper.setTable(table, i, migrationType);
                }
                dataxJsonHelper.setColumns(tables.get(0), migrationType);

                // 输出最终Json配置
                FileWriter inputWriter = new FileWriter(Configuration.IMPORT_OUT_DIR + "/" + Configuration.MYSQL_DATABASE_IMPORT + "." + tables.get(0).name() + ".json");
                JSONUtil.toJsonStr(dataxJsonHelper.getInputConfig(), inputWriter);
                inputWriter.close();
            } else {
                for (Table table : tables) {
                    // 设置表信息
                    dataxJsonHelper.setTableAndColumns(table, 0, migrationType);

                    // 输出最终Json配置
                    FileWriter inputWriter = new FileWriter(Configuration.IMPORT_OUT_DIR + "/" + Configuration.MYSQL_DATABASE_IMPORT + "." + table.name() + ".json");
                    JSONUtil.toJsonStr(dataxJsonHelper.getInputConfig(), inputWriter);
                    inputWriter.close();
                }
            }
        }

        // 生成 HDFS 出方向配置文件
        if (Configuration.EXPORT_OUT_DIR != null &&
                !"".equals(Configuration.EXPORT_OUT_DIR)) {
            MysqlHelper mysqlHelper = new MysqlHelper(
                    Configuration.MYSQL_URL_EXPORT,
                    Configuration.MYSQL_DATABASE_EXPORT,
                    Configuration.MYSQL_TABLES_EXPORT);
            DataxJsonHelper dataxJsonHelper = new DataxJsonHelper();

            // 获取迁移操作类型
            String migrationType = Configuration.EXPORT_MIGRATION_TYPE;

            // 创建父文件夹
            Files.createDirectories(Paths.get(Configuration.EXPORT_OUT_DIR));
            List<Table> tables = mysqlHelper.getTables();

            if (Configuration.IS_SEPERATED_TABLES.equals("1")) {
                for (int i = 0; i < tables.size(); i++) {
                    Table table = tables.get(i);
                    dataxJsonHelper.setTable(table, i, migrationType);
                }
                dataxJsonHelper.setColumns(tables.get(0), migrationType);

                // 输出最终Json配置
                FileWriter outputWriter = new FileWriter(Configuration.EXPORT_OUT_DIR + "/" + Configuration.MYSQL_DATABASE_EXPORT + "." + tables.get(0).name() + ".json");
                JSONUtil.toJsonStr(dataxJsonHelper.getOutputConfig(), outputWriter);
                outputWriter.close();
            }

            for (Table table : tables) {
                // 设置表信息
                dataxJsonHelper.setTableAndColumns(table, 0, migrationType);
                // 输出最终Json配置
                FileWriter outputWriter = new FileWriter(Configuration.EXPORT_OUT_DIR + "/" + Configuration.MYSQL_DATABASE_EXPORT + "." + table.name() + ".json");
                JSONUtil.toJsonStr(dataxJsonHelper.getOutputConfig(), outputWriter);
                outputWriter.close();
            }
        }
    }
}

二、如何使用

2.1 ​​​​​​ 修改配置文件

在项目根目录新建配置文件：configuration.properties

key

default

description

mysql.username

root

MySQL用户名

mysql.password

000000

MySQL密码

mysql.host

hadoop102

MySQL所在Host

mysql.port

3306

MySQL端口号

mysql.database.import

ad

导入HDFS的数据库

mysql.database.export

ad_report

从HDFS导出的数据库

mysql.tables.import

""

需要导入的表，空字符串表示全部导入

mysql.tables.export

""

需要导出的表，空字符串表示全部导出

is.seperated.tables

0

是否为分表，0为否

hdfs.uri

hdfs://hadoop102:8020

HDFS Namenode 地址

import_out_dir

null

导入HDFS的配置文件输出地址

export_out_dir

null

从HDFS导出的配置文件输出地址

文件内容如下。

mysql.username=root
mysql.password=000000
mysql.host=hadoop102
mysql.port=3306
mysql.database.import=ad
mysql.database.export=ad_report
mysql.tables.import=
mysql.tables.export=
is.seperated.tables=0
hdfs.uri=hdfs://hadoop102:8020
import_out_dir=d:/output/import
export_out_dir=d:/output/export

2.2 运行

执行mvn clean package打包，target目录会生成datax-config-generator-1.0-SNAPSHOT-jar-with-dependencies.jar。和configuration.properties文件一并拷入Linux，执行即可：

[atguigu@hadoop102 ~]$ java -jar datax-config-generator-1.0-SNAPSHOT-jar-with-dependencies.jar

星星法术嗲人
关注
  • 3
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
DataX配置文件生成器
10-11
DataX配置文件生成器
datax on azkaban——datax as a service
11-03
在提供的压缩包中，"datax_scheduler"可能包含了Azkaban中的作业配置和调度文件，这些文件定义了DataX任务如何在Azkaban中运行，包括作业的输入参数、依赖关系、执行命令等。而"datax_service"可能是一个服务端实现...
大数据技术——Hadoop 3.X版本(入门知识)
weixin_52424868的博客
08-09 630
一篇小短文带你简单了解Hadoop！
Hear大数据项目——Hera推荐系统需求分析
庄小焱
08-04 4945
大数据技术之电商推荐系统源码：https://github.com/2462612540/Big_Data_Spark_Scala_hadoop.git 1 项目体系架构设计 1.1系统架构设计 项目以推荐系统建设领域知名的经过修改过的中文亚马逊电商数据集作为依托，以某电商网站真实业务数据架构为基础，构建了符合教学体系的一体化的电商推荐系统，包含了离线推荐与实时推荐体系，综合利用了协同过滤算法以及基于内容的推荐方法来提供混合推荐。提供了从前端应用、后台服务、算法设计实现、平台部署等多方位的闭环的业务实
大数据高级开发工程师——大数据相关工具之二 DataX
yangwei2048的博客
01-03 1839
文章目录大数据相关工具DataX数据同步工具DataX 3.0架构设计DataX 3.0 插件体系DataX 3.0 核心架构1. 核心模块介绍2. DataX调度流程DataX 安装部署DataX 实战案例1. 从stream流读取数据并打印到控制台2. 从mysql表读取数据并打印到控制台3. 从mysql表读取增量数据并打印到控制台4. 使用datax实现mysql2mysql5. 使用datax实现将mysql数据导入到hdfs6. 使用datax实现将hdfs数据导入到mysql表中7. 使用da
大数据Hadoop之——总结篇
匠人精神，持之以恒！
08-22 4345
前面已经介绍了几乎企业里使用到的绝大多数大数据组件了，这里来个简单的总结，主要针对常见的操作进行总结。也方便自己和大家在工作中快速查阅。
大数据ETL工具对比——SeaTunnel、DataX、Sqoop、Flume、Flink CDC、Dlinky、TIS、Chunjun等对比
u011047968的专栏
05-16 3275
Apache SeaTunnel作为下一代数据集成平台。同时也是数据集成一站式的解决方案，有下面这么几个特点。丰富且可扩展的Connector：SeaTunnel提供了不依赖于特定执行引擎的Connector API。基于该API开发的Connector（Source、Transform、Sink）可以运行在很多不同的引擎上，例如目前支持的SeaTunnel Engine、Flink、Spark等。
大数据之路——数据同步（第三章）
weixin_42712867的博客
01-24 588
如第一章所述，我们将数据采集分为日志采集和数据库数据同步两。数据同步技术更通用的含义是不同系统间的数据流转，有多种不。主数据库与备份数据库之间的数据备份，以及主系统与。子系统之间的数据更新，属于同类型不同集群数据库之间的数据同步。另外，还有不同地域、不同数据库类型之间的数据传输交换，比如分布。式业务系统与数据仓库系统之间的数据同步。服务或数据应用两个方面。本章侧重讲解数据从业务系统同步进入数据。含数据从业务系统同步进入数据仓库和数据从数据仓库同步进入数据。仓库这个环节，但其适用性并不仅限于此。
Apache DolphinScheduler——开源大数据调度器神器
LXWalaz1s1s的博客
06-11 8903
手把手教您玩转开源大数据调度器Apache DolphinScheduler安装维护与实践，学不会你来打我。
Hadoop大数据技术生态
Universe — Higher and farther
12-29 854
一、大数据技术生态图 Ambari：可以安装、部署及管理hadoop、hive、hbase、zk等集群。 HDFS：Hadoop中的分布式文件存储系统。 Yarn：Hadoop中的集群资源管理和调度系统。 MapReduce：Hadoop中的分布式离线计算框架。 Spark：分布式内存计算框架。包括sparkcore、sparkstreaming、sparkmllib等组件。 Tez：对MapReduce任务进行优化，加快执行速度。 ...
大数据工程师零基础起步——成长路线引入
ElsaWu的布袋子
08-06 437
即写即用大数据开发基础1 编程语言1.1 JAVA1.2 Scala（优先级靠后，有遇到需要用的时候再学，如Spark）2 数据结构和算法3 计算机网络4 操作系统5 数据库基础6 设计模式7 LINUX系统（使用层面）基本开发工具1 Linux操作系统2 SSH终端3 FTP/SFTP工具4 IDE5 源码控制工具6 构建工具具体流程——数据采集1 数据类型2 数据来源3 数据采集（收集/聚合）3.1 Flume(分布式的数据采集和聚合框架)3.2 Logstash（开源数据收集引擎）4 数据迁移（同步/
大数据ETL DataX技术资料
04-10
大数据ETL DataX技术资料
阿里巴巴大数据之路——数据技术篇.pdf
12-24
总的来说，阿里巴巴大数据技术路径展示了从数据采集、存储、处理到应用的全面流程，并强调了在不同场景下如何有效地同步和管理数据，以满足实时性、一致性和效率的需求。这不仅涉及到工具的选用，也涵盖了数据处理...
大数据采集技术-DataX概述.pptx
12-23
大数据采集技术是现代数据分析领域的重要组成部分，而DataX作为一个高效的数据同步工具，为解决异构数据源之间的数据流动提供了强大的支持。本篇文章将深入探讨DataX的技术概览、工作流程以及其主要特点。 首先，...
elasticsearch教程
08-05 1193
1. IP案例:(1)创建索引时指定映射关系(2)查看索引的映射关系(3)创建测试数据(4)查看数据"query":{"match":{(5)删除数据2. date案例:(1)创建索引时指定映射关系(2)查看索引的映射关系(3)创建测试数据(4)查看数据(5)删除数据-3 综合案例(1)创建索引(2)查看索引信息(3)为已创建的索引修改数据类型"name": {},},},"city": {},"email": {},},(4)添加测试数据。
如何礼貌且高效地应对工作中的无关问题
一个7年大数据开发工程师的碎碎念
08-05 1090
通过这篇博客文章，你不仅学到了应对无关问题的策略，还获得了实用的代码示例，希望能为你的工作带来帮助。礼貌且高效地应对无关问题，不仅仅是简单的回应或拒绝，更重要的是培养一种积极的工作态度和解决问题的能力。在繁忙的工作环境中，设定清晰的边界是非常重要的。今天，我将分享一些有效的策略和具体的代码示例，帮助你礼貌且高效地应对这些无关问题，让你在忙碌的工作中依然能够保持高效。然而，总有一些同事或朋友会提出一些与工作无关的问题，这些问题不仅会分散我们的注意力，还可能影响我们的工作效率。在工作中，团队合作是非常重要的。
【大数据】探索大数据基础知识：定义、特征与生态系统
在路上的专栏
08-05 715
大数据技术在过去十年间飞速发展，已经成为驱动现代商业、科学研究和社会进步的重要力量。本篇文章将深入探讨大数据的基本概念，详细解析其定义与特征，包括数据的体量、速度、多样性和真实性。我们将介绍大数据的生态系统，涵盖核心组件如Hadoop、Spark、NoSQL数据库等，并解析其在存储、处理和分析海量数据中的应用。通过对大数据技术的全面剖析，读者将获得对这一领域的深刻理解，为进一步探索和应用大数据技术奠定坚实基础。
ANN（Approximate Nearest Neighbor）搜索和索引库到底是什么？
最新发布
叶庭云 成为自己的光
08-06 876
ANN（Approximate Nearest Neighbor）搜索和索引库到底是什么？
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值