sparkstreaming + sparksql实现ETL操作

最新推荐文章于 2024-09-10 08:34:23 发布
最新推荐文章于 2024-09-10 08:34:23 发布
阅读量660 收藏 2
点赞数
分类专栏： 大数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39884410/article/details/118310435
版权

代码磨了半天做个记录（删了业务相关的代码）：
spark-2.4.0

Oracle2ODPS例子：

import aliyun.spark.test.odps2oracle.util.MessageMapperUtilOracle;
import aliyun.spark.test.util.PropertiesUtil;
import org.apache.spark.sql.Dataset;
import org.apache.spark.sql.Row;
import org.apache.spark.sql.SparkSession;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;

/**
 * 读取odps上的数据，写入oracle数据库
 * args[0] 运行模式，local或cluster
 * args[1] odps源表名
 * args[2] oracle结果表名
 * args[3] numPartitions 分区数量
 */
public class Oracle2ODPS {

   
    public static void main(String[] args) {

        System.out.println("args[]:" + Arrays.toString(args));
        SparkSession ss;
        if(args[0] != null && args[0].equals("local")){
            // 本地执行
            // 需设置spark.master为local[N]才能直接运行，N为并发数
            ss = SparkSession.builder().appName("ORACLE_TO_ODPS").config("spark.master", "local[2]")
                    .config("spark.hadoop.odps.project.name", "xxxxx")
                    .config("spark.hadoop.odps.access.id", "xxxxx")
                    .config("spark.hadoop.odps.access.key", "xxxxx")
                    .config("spark.hadoop.odps.end.point", "xxxxx")
                    .config("spark.hadoop.tunnel.end.point","xxxxx")
                    .config("spark.sql.catalogImplementation", "odps")
                    .config("spark.testing.memory", 2147480000)
                    .config("odps.exec.dynamic.partition.mode","nonstrict")
                    .config("spark.hadoop.fs.oss.accessKeyId","")
                    .config("spark.hadoop.fs.oss.accessKeySecret","")
                    .config("spark.hadoop.fs.oss.endpoint","oss-cn-beijing.aliyuncs.com")
                    .getOrCreate();
        }else {
            //集群执行
            ss = SparkSession.builder().appName("ORACLE_TO_ODPS").config("odps.exec.dynamic.partition.mode","nonstrict").getOrCreate();
        }
     

     
        // 读oracle数据
        Dataset<Row> jdbcJcDF = ss.read().format("jdbc")
                .option("driver", PropertiesUtil.getProperty("oracle.driver"))
                .option("url", PropertiesUtil.getProperty("oracle.url"))
                .option("user", PropertiesUtil.getProperty("oracle.user"))
                .option("password", PropertiesUtil.getProperty("oracle.password"))
                .option("dbtable", "(select  MOD(ASCII(SUBSTR(ROWID, -1)), 20) as RN ,q.* from " + oracleTable +" q)")
                .option("numPartitions",4)
                .option("partitionColumn", "RN")
                .option("lowerBound", 0)
                .option("upperBound", 20)
                .option("fetchsize", "10000").load();

       // jdbcDF.show();
        System.out.println("开始写入...");

        // 写分区表
        jdbcJcDF.createOrReplaceTempView(oracleTable + "_TMP");
        ss.sql("insert overwrite table XXX_ALL  partition (DS='" + ds + "') select " + allColume + " from " + oracleTable + "_TMP");

        ss.close();
        System.out.println("spark run over!");
    }




    public static String fieldConvertToOdpsField(String name, String dataType) {
     // 代码删除了
    }

    /**
     * 创建odps上分区表
     * SparkSession ss
     * String database 指定数据库
     * String mapperName 指定mapper对应的表
     * Boolean flag 是否删表重建
     * @author Administrator
     */
    public static String createOdpsTableAll(SparkSession ss, String database, String mapperName, Boolean flag){
   // 代码删除了
      
    }


    public static String createOdpsETLTableAll(SparkSession ss, String database, String mapperName, Boolean flag){
     // 代码删除了
    }


    private static String calculateDateString(String dateString , int dayNum , String dateFormat){
        Calendar calendar = Calendar.getInstance();
        SimpleDateFormat formatter = new SimpleDateFormat(dateFormat);
        Date date = null ;
        try {
            date = formatter.parse(dateString);
        } catch (ParseException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        calendar.setTime(date);
        calendar.add(Calendar.DAY_OF_MONTH, dayNum);
        return formatter.format(calendar.getTime());
    }

}

Kafka2ODPS例子：


import aliyun.spark.test.util.SparkSessionSingleton;
import com.alibaba.fastjson.JSONObject;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.common.serialization.StringDeserializer;
import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.function.Function;
import org.apache.spark.sql.Dataset;
import org.apache.spark.sql.Row;
import org.apache.spark.sql.RowFactory;
import org.apache.spark.sql.SparkSession;
import org.apache.spark.sql.types.DataType;
import org.apache.spark.sql.types.DataTypes;
import org.apache.spark.sql.types.StructField;
import org.apache.spark.sql.types.StructType;
import org.apache.spark.streaming.Durations;
import org.apache.spark.streaming.api.java.JavaDStream;
import org.apache.spark.streaming.api.java.JavaInputDStream;
import org.apache.spark.streaming.api.java.JavaStreamingContext;
import org.apache.spark.streaming.kafka010.ConsumerStrategies;
import org.apache.spark.streaming.kafka010.KafkaUtils;
import org.apache.spark.streaming.kafka010.LocationStrategies;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;

/**
 *   这个代码比较全点， 删了一些业务相关的
 */
public class SparkKafka2Odps {


    public static void main(String[] args) throws InterruptedException {

  

        Date nowDate = new Date();
        SimpleDateFormat nowFormat = new SimpleDateFormat("yyyyMMdd");
        String sysDate = nowFormat.format(nowDate);
        String ds = calculateDateString(sysDate, 0, "yyyyMMdd");

        SparkConf conf = new SparkConf().setAppName("sparkStreaming-kafka-odps")
                .set("spark.driver.allowMultipleContexts","true")
                .set("spark.task.maxFailures","10")
                .set("spark.serializer", "org.apache.spark.serializer.KryoSerializer")
                .set("spark.hadoop.odps.project.name", "xxx\")
                .set("spark.hadoop.odps.access.id", "xxx")
                .set("spark.hadoop.odps.access.key", "xxx")
                .set("spark.hadoop.odps.end.point", "xxx")
                .set("spark.hadoop.tunnel.end.point","xxx")
                .set("spark.sql.catalogImplementation", "odps")
                .set("odps.exec.dynamic.partition.mode","nonstrict")
                .set("spark.hadoop.fs.oss.accessKeyId","")
                .set("spark.hadoop.fs.oss.accessKeySecret","")
                .set("spark.hadoop.fs.oss.endpoint","oss-cn-beijing.aliyuncs.com")
                .setMaster("local[1]");

        JavaStreamingContext streamingContext = new JavaStreamingContext(conf, Durations.seconds(1));

        streamingContext.sparkContext().setLogLevel("WARN");

        String schemaString = createOdpsTable(SparkSessionSingleton.getInstance("local"), "", mapperName,odpsTableName, true);

       // System.out.println(schemaString);

        Map<String, Object> kafkaParams = new HashMap<>();
        kafkaParams.put("bootstrap.servers", "xxx:9092,xxx:9092,xxx:9092");
        kafkaParams.put("key.deserializer", StringDeserializer.class);
        kafkaParams.put("value.deserializer", StringDeserializer.class);
        kafkaParams.put("group.id", "xxxxxx");
        kafkaParams.put("auto.offset.reset", "earliest");
        //  kafkaParams.put("auto.offset.reset", "latest");
        kafkaParams.put("enable.auto.commit", false);

        Set<String> topicsSet = new HashSet<>(Arrays.asList("xxxxxx"));


        final JavaInputDStream<ConsumerRecord<String, String>> stream =
                KafkaUtils.createDirectStream(
                        streamingContext,
                        LocationStrategies.PreferConsistent(),
                        ConsumerStrategies.<String, String>Subscribe(Arrays.asList(topicsSet.toArray(new String[0])), kafkaParams)
                );

        JavaDStream<ConsumerRecord<String, String>> repartition = stream.repartition(6);

        JavaDStream<String> lines = repartition.map(ConsumerRecord::value);

        OracleTableMapper tableMapperByOracle = MessageMapperUtilOracle.getTableMapper("", mapperName);
        List<OracleColumnMapper> columns = tableMapperByOracle.getColumns();
        List<StructField> fields = new ArrayList<>();
        for (OracleColumnMapper c : columns){
            StructField field = DataTypes.createStructField(c.getName(), fieldConvertToSparkField(c.getDataType()), true);
            fields.add(field);
        }

        StructType schema = DataTypes.createStructType(fields);

        StructField[] filedArray = schema.fields();

        String[] split = new String[filedArray.length];


        for (int i = 0; i < filedArray.length; i++) {
            StructField structField = filedArray[i];
            String name = structField.name();
            split[i] = name;
        }


        // Convert RDDs of the words DStream to DataFrame and run SQL query
        /*************START****************/
        lines.foreachRDD((rdd,time)->{
            // Get the singleton instance of SparkSession
            SparkSession spark = SparkSessionSingleton.getInstance("local");

            JavaRDD<Row> rowRDD = rdd.filter( str -> {
                if("".equals(str) || str == null){
                    return false;
                }
                return true;
            }).map((Function<String, Row>) record -> {

 //               System.out.println(record);
                Map map = (Map)JSONObject.parse(record);

                Object[] objects = new Object[filedArray.length];

                for (int i = 0; i < objects.length; i++) {
                    objects[i] =  String.valueOf(map.get(split[i].toLowerCase()));
                }

                return   RowFactory.create(objects);
            });


            Dataset<Row> dataFrame = spark.createDataFrame(rowRDD, schema);

           // dataFrame.printSchema();



            dataFrame.createOrReplaceTempView(mapperName+"_TMP");

            //Dataset<Row>   wordCountsDataFrame =  spark.sql("select * from " + mapperName+"_TMP limit 10 ");
            spark.sql("insert into table  " + odpsTableName + "  partition (DS='" + ds + "') select * from "+mapperName+"_TMP");

            //wordCountsDataFrame.show();
            System.out.println("========= " + time + "=========");
        });

        /*************END****************/
        streamingContext.start();
        streamingContext.awaitTermination();
    }




    /**
     * 创建odps上分区表
     * SparkSession ss
     * String database 指定数据库
     * String mapperName 指定mapper对应的表
     * Boolean flag 是否删表重建
     * @author Administrator
     */
    public static String createOdpsTable(SparkSession ss, String database, String mapperName,String odpsTableName, Boolean flag){

        String allColume = "";

        OracleTableMapper tableMapperByOracle = MessageMapperUtilOracle.getTableMapper(database,mapperName);
        if(tableMapperByOracle!=null){
            List<OracleColumnMapper> columns = tableMapperByOracle.getColumns();
            String str1 = "CREATE TABLE  IF NOT EXISTS " + odpsTableName + " (";
            String str2 = "";
            for (OracleColumnMapper c : columns){
                str2 += c.getName() + " " +  fieldConvertToOdpsField(c.getName(),c.getDataType()) + ", ";
                allColume +=  c.getName() + ", ";
            }
            String str3 = str2.substring(0, str2.length() -2);
            String str4 = ") PARTITIONED BY (DS STRING)";
            String str5 = str1 + str3 + str4;

            System.out.println(mapperName + "建表语句： " + str5);

            allColume =  allColume.substring(0, allColume.length() -2);

            // 是否删表
            if (flag) {
                ss.sql("drop table " + odpsTableName);
            }
            Dataset<Row> sql = ss.sql(str5);

        }
        return allColume;
    }


    public static String fieldConvertToOdpsField(String name, String dataType) {
        String str = null;
        if("NUMBER".equals(dataType)) {
            str = "BIGINT";
        }else if("VARCHAR2".equals(dataType)) {
            str = "STRING";
        }else if("DATE".equals(dataType)) {
            str = "STRING";
        }else{
            str = "DOUBLE";
        }
        return str;
    }

    public static DataType fieldConvertToSparkField(String name) {
        if("NUMBER".equals(name)) {
            return DataTypes.StringType;
        }else if("VARCHAR2".equals(name)) {
            return DataTypes.StringType;
        }else if("DATE".equals(name)) {
          //  return DataTypes.DateType;
            return DataTypes.StringType;
        } else if("DECIMAL".equals(name)) {
            //  return DataTypes.DateType;
            return DataTypes.StringType;
        }
        else{
            return DataTypes.StringType;
        }
    }


    private static String calculateDateString(String dateString , int dayNum , String dateFormat){
        Calendar calendar = Calendar.getInstance();
        SimpleDateFormat formatter = new SimpleDateFormat(dateFormat);
        Date date = null ;
        try {
            date = formatter.parse(dateString);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        calendar.setTime(date);
        calendar.add(Calendar.DAY_OF_MONTH, dayNum);
        return formatter.format(calendar.getTime());
    }


}

// 单例的sparksession
public class SparkSessionSingleton {

    private static SparkSession ss;

    public static SparkSession getInstance(String flag){

        if  (ss == null){

            if("local".equals(flag)){
                ss = SparkSession.builder()
                        .config("spark.master", "local[2]")
                        .config("spark.hadoop.odps.project.name", "xxx")
                        .config("spark.hadoop.odps.access.id", "xxx")
                        .config("spark.hadoop.odps.access.key", "xxx")
                        .config("spark.hadoop.odps.end.point", "xxx")
                        .config("spark.hadoop.tunnel.end.point","xxx")
                        .config("spark.sql.catalogImplementation", "odps")
                        .config("spark.testing.memory", 2147480000)
                        .config("odps.exec.dynamic.partition.mode","nonstrict")
                        .config("spark.hadoop.fs.oss.accessKeyId","")
                        .config("spark.hadoop.fs.oss.accessKeySecret","")
                        .config("spark.hadoop.fs.oss.endpoint","xxx")
                        .getOrCreate();
            }else {
                //集群执行
                ss = SparkSession.builder().appName("ORACLE_TO_ODPS")               .config("odps.exec.dynamic.partition.mode","nonstrict").getOrCreate();
            }

        }

        return ss;

    }

备注：sparkstreaming+sparksql是可以使用的，注意sparksession只能有一个。

Spark的生态系统概览：Spark SQL、Spark Streaming
晓晓的天空
12-26 1473
Spark SQL和Spark Streaming是Apache Spark生态系统中的两个核心组件，分别用于结构化数据处理和实时数据处理。了解它们的功能、适用场景和示例应用场景有助于更好地决策何时使用哪个组件。无论是处理大规模数据分析还是实时数据处理，Spark SQL和Spark Streaming都提供了强大的工具和API，支持各种数据处理需求。希望本文帮助大家个组件，并为大数据处理项目提供有力的支持。
SparkStreaming实时ETL
weixin_44863639的博客
03-18 329
SparkStreaming实时在线ETL 描述：使用Scala和Java编程 1.和kafka整合，通过kafka生产数据，然后把数据传入sparkstreaming进行在线 ETL; 2.把ETL后的数据在传入kafka，通过kafka消费数据 3.通过Redis进行数据偏移量的管理，从而保证每次从正确位置消费数据，防止数 据丢失。 1.项目父依赖 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="h
spark替代Hive实现ETL作业
10-08
spark替代Hive实现ETL作业
ETL SparkSQL实现
dazheng
04-07 3033
SparkETL SparkETL主要用SQL方式实现数据仓库ETL，并保持spark的原生多功能、灵活性。采用java对spark功能进行简单封装，对于数据源、目标都是关系型数据库的，从数据抽取、转换、加载完全采用SQL方式，对于SQL不满足的场景，再用spark相关功能实现。 SparkETL是ETL的一个参考实现，实际使用时，需要根据业务需要及模型设计在此基础上增加、修改。 实现背景 Spa...
Spark 集群进行 ETL 的架构介绍
最新发布
跟着大数据和AI去旅行
09-10 1056
什么是ETL ETL（extract提取、transform转换、load加载）。ETL负责将分散的、异构数据源中的数据如关系数据、平面数据文件等抽取到临时中间层后，进行清洗、转换、集成，最后加载到数据仓库或数据集市中，成为联机分析处理、数据挖掘提供决策支持的数据。 使用Spark开发ETL系统的优势 由于海量的日志记录、交易记录，单机进行ETL变得越来越困难。搭建一套具备大规模数据处
Spark Streaming + Spark SQL 实现配置化ETL流程
allwefantasy的专栏
04-27 1798
Spark Streaming 非常适合ETL。但是其开发模块化程度不高，所以这里提供了一套方案，该方案提供了新的API用于开发Spark Streaming程序，同时也实现了模块化，配置化，并且支持SQL做数据处理。 项目地址 前言 传统的Spark Streaming程序需要： 构建StreamingContext 设置checkpoint 链接...
使用Spark Streaming SQL基于时间窗口进行数据统计
chikuai9995的博客
07-08 1168
1.背景介绍 流式计算一个很常见的场景是基于事件时间进行处理，常用于检测、监控、根据时间进行统计等系统中。比如埋点日志中每条日志记录了埋点处操作的时间，或者业务系统中记录了用户操作时间，用于统计各种操作处理的频率等，或者根据规则匹配，进行异常行为检测或监控系统告警。这样的时间数据都会包含在...
Spark的Streaming和Spark的SQL简单入门学习
weixin_34080951的博客
04-23 343
1、Spark Streaming是什么？ a、Spark Streaming是什么？　　Spark Streaming类似于Apache Storm，用于流式数据的处理。根据其官方文档介绍，Spark Streaming有高吞吐量和容错能力强等特点。Spark Streaming支持的数据输入源很多，例如：Kafka、Flume、Twitter、ZeroMQ和简单的TCP套接字等等。数据输...
基于Spark Streaming+ALS的餐饮智能推荐系统.zip
07-31
离线数据处理：SparkSQL (做数据查询引擎<===> 数据ETL) 实时数据处理：Kafka + Spark Streaming 数据应用层：MLlib 产生一个模型 als算法 数据展示和对接：Zeppelin 选用考量： HDFS不管是在存储的性能，稳定...
基于机器学习+Spark2.0+MongoDB实现的协同过滤推荐系统.zip
07-31
离线数据处理：SparkSQL (做数据查询引擎<===> 数据ETL) 实时数据处理：Kafka + Spark Streaming 数据应用层：MLlib 产生一个模型 als算法 数据展示和对接：Zeppelin 选用考量： HDFS不管是在存储的性能，稳定...
SparkSQL在ETL中的应用与优势
7. Structured Streaming：SparkSQL也支持Structured Streaming，这是一种处理连续数据流的API，可以用于实时ETL场景，将批处理和流处理统一在一个简单的API下。 SparkSQL凭借其强大的数据处理能力、丰富的数据源...
基于Spark+Flask+Mongodb的在线电影推荐系统设计与实现.zip
07-31
离线数据处理：SparkSQL (做数据查询引擎<===> 数据ETL) 实时数据处理：Kafka + Spark Streaming 数据应用层：MLlib 产生一个模型 als算法 数据展示和对接：Zeppelin 选用考量： HDFS不管是在存储的性能，稳定...
SparkSQL在ETL中的应⽤用.pdf
11-07
SparkSQL在ETL中的应⽤用.pdf
Spark Streaming与Spark SQL结合操作详解
蔡政洁的博客
12-19 2194
Spark Streaming最强大的地方在于，可以与Spark Core、Spark SQL整合使用，之前已经通 过transform、foreachRDD等算子看到，如何将DStream中的RDD使用Spark Core执行批处理操 作。现在就来看看，如何将DStream中的RDD与Spark SQL结合起来使用。 案例：每隔10秒，统计最近60秒的，每个种类的每个商品的点击次数，然后统计出每个种类 top3热门的商品。 数据输入模型： -------------------------- 姓名 商品
SparkSQL ETL
Java大数据
10-14 1724
记一次SparkSql ETL 过程 需求： 1）input：json日志 2）ETL：根据IP解析出 省份，城市 3）stat: 地区分布指标计算， 满足条件的才算，满足条件的赋值为1，不满足的赋值为0 （如下图） 将统计结果写入MySQL中。 （就比如说这个广告请求要满足 requestmode=1 和 processnode =3 这两个条件） val spark = SparkSessi...
大数据Hadoop之——Spark SQL+Spark Streaming
匠人精神，持之以恒！
12-25 2716
文章目录一、Spark SQL概述二、SparkSQL版本1）SparkSQL的演变之路2）shark与SparkSQL对比3）SparkSession三、RDD、DataFrames和DataSet1）三者关联关系1）RDD1、核心概念2、RDD简单操作3、RDD API1）Transformation2）Action4、实战操作2）DataFrames1、DSL风格语法操作1）DataFrame创建2、SQL风格语法操作3）DataSetRDD，DataFrame，DataSet互相转化四、RDD、Da
SparkStreaming使用SQL
lbship的博客
12-19 2516
直接上代码，例子来源于官网的wordcount例子 package Sparkstreaming import org.apache.spark.SparkConf import org.apache.spark.rdd.RDD import org.apache.spark.sql.SparkSession import org.apache.spark.storage.StorageLe...
pyspark sparkStreaming
weixin_42529756的博客
02-28 1222
1、sparkStreaming概述 1.1 SparkStreaming是什么 它是一个可扩展，高吞吐具有容错性的流式计算框架 吞吐量：单位时间内成功传输数据的数量 之前我们接触的spark-core和spark-sql都是处理属于离线批处理任务，数据一般都是在固定位置上，通常我们写好一个脚本，每天定时去处理数据，计算，保存数据结果。这类任务通常是T+1(一天一个任务)，对实时性要求不高。 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lOXxEes0-161452
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值