一篇文章学会 Spark 数据读写代码开发

已于 2022-03-20 01:06:11 修改
阅读量3k 收藏
点赞数 2
分类专栏： 大数据技术体系 文章标签： spark scala 大数据
于 2022-03-13 23:57:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Shockang/article/details/123468811
版权

前言

本文隶属于专栏《大数据技术体系》，该专栏为笔者原创，引用请注明来源，不足和错误之处请在评论区帮忙指出，谢谢！

本专栏目录结构和参考文献请见大数据技术体系

源码下载

spark-examples 代码已开源，本项目致力于提供最具实践性的 Apache Spark 代码开发学习指南。

点击链接前往 github 下载源码：spark-examples

正文

读

Collection

package com.shockang.study.spark.core.read

import org.apache.spark.{SparkConf, SparkContext}

object ReadCollectionRDDExample {
  def main(args: Array[String]): Unit = {
    // 初始化 SparkConf 对象，设置基本任务参数
    val conf: SparkConf = new SparkConf()
      // 设置提交任务的目标 Master 机器地址，local 为本地运行，[*]为自动分配任务线程数
      .setMaster("local[*]")
      // 设置任务名称
      .setAppName("ReadObjectRDDExample")

    //创建SparkContext对象，通过传入SparkConf实例来定制Spark运行的具体参数和配置信息
    val sc = new SparkContext(conf)

    val numbers = 1 to 100
    val rdd = sc.parallelize(numbers)

    //1+2=3 3+3= 6 6+4=10 .....
    val sum = rdd.reduce(_ + _)

    println("1+2+....+ 99+100 = " + sum)
  }

}

package com.shockang.study.spark.sql.read

import org.apache.spark.sql.types.{IntegerType, StringType, StructField, StructType}
import org.apache.spark.sql.{Row, SparkSession}

/**
 * 读取 csv/tsv 文件
 *
 * @author Shockang
 */
object ReadCollectionDataFrameExample {
  def main(args: Array[String]): Unit = {

    // 使用 Spark 2.0 提供的 SparkSession API 来访问应用程序
    val spark = SparkSession.builder().master("local[*]").appName("ReadCsvDataFrameExample").getOrCreate()

    val df1 = spark.createDataFrame(List(
      ("Alice", "Female", "20"),
      ("Tom", "Male", "25"),
      ("Boris", "Male", "18"))).toDF("name", "sex", "age")
    df1.show()

    val schema = StructType(List(
      StructField("name", StringType, nullable = true),
      StructField("age", IntegerType, nullable = true),
      StructField("sex", StringType, nullable = true)
    ))

    val javaList = new java.util.ArrayList[Row]()
    javaList.add(Row("Alice", 20, "Female"))
    javaList.add(Row("Tom", 18, "Male"))
    javaList.add(Row("Boris", 30, "Male"))
    val df2 = spark.createDataFrame(javaList, schema)
    df2.show

    // 停止sc，结束该任务
    spark.stop()
  }
}

CSV

package com.shockang.study.spark.core.read

import com.shockang.study.spark.READ_DATA_DIR
import org.apache.spark.{SparkConf, SparkContext}

object ReadCsvRDDExample {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf()
      .setMaster("local[*]")
      .setAppName("ReadCsvRDDExample")
    val sc = new SparkContext(conf)
    sc.setLogLevel("ERROR")

    //读取CSV文件
    val inputCSVFile = sc.textFile(READ_DATA_DIR + "people.csv").flatMap(_.split(",")).collect
    inputCSVFile.foreach(println)
    //读取TSV文件
    val inputTSVFile = sc.textFile(READ_DATA_DIR + "people.tsv").flatMap(_.split("\t")).collect
    inputTSVFile.foreach(println)

    //停止sc，结束该任务
    sc.stop()
  }
}


package com.shockang.study.spark.sql.read

import com.shockang.study.spark._
import org.apache.spark.sql.SparkSession

/**
 * 读取 csv/tsv 文件
 *
 * @author Shockang
 */
object ReadCsvDataFrameExample {
  def main(args: Array[String]): Unit = {

    // 使用 Spark 2.0 提供的 SparkSession API 来访问应用程序
    val spark = SparkSession.builder().master("local[*]").appName("ReadCsvDataFrameExample").getOrCreate()
    // 读取 csv 文件
    val inputCsvFile = spark.read.csv(READ_DATA_DIR + "people.csv")
    // 结果日志输出
    printArray(inputCsvFile.collect)

    // 读取 tsv 文件
    val inputTsvFile = spark.read.option("delimiter", "\\t").csv(READ_DATA_DIR + "people.tsv")
    // 结果日志输出
    printArray(inputTsvFile.collect)

    // 停止sc，结束该任务
    spark.stop()
  }
}

Hadoop

package com.shockang.study.spark.core.read

import com.shockang.study.spark._
import org.apache.hadoop.io.{LongWritable, Text}
import org.apache.hadoop.mapred
import org.apache.hadoop.mapreduce.lib.input.TextInputFormat
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}

object ReadHadoopRDDExample {
  def main(args: Array[String]): Unit = {
    // 初始化 SparkConf 对象，设置基本任务参数
    val conf: SparkConf = new SparkConf()
      // 设置提交任务的目标 Master 机器地址，local 为本地运行，[*]为自动分配任务线程数
      .setMaster("local[*]")
      // 设置任务名称
      .setAppName("ReadHadoopRDDExample")
    // 实例化 SparkContext
    val sc: SparkContext = new SparkContext(conf)

    val path: String = HDFS_READ_DIR + "people.txt"

    // 使用 Hadoop 旧 API
    val oldHadoopRDD: RDD[(LongWritable, Text)] = sc.hadoopFile[LongWritable, Text, mapred.TextInputFormat](path)
    printArray(oldHadoopRDD.map(_._2.toString).collect)

    // 使用 Hadoop 新 API
    val newHadoopRDD: RDD[(LongWritable, Text)] = sc.newAPIHadoopFile[LongWritable, Text, TextInputFormat](path)
    printArray(newHadoopRDD.map(_._2.toString).collect)

    sc.stop
  }
}

JSON

package com.shockang.study.spark.core.read

import com.shockang.study.spark.READ_DATA_DIR
import org.apache.spark.{SparkConf, SparkContext}

import scala.util.parsing.json.JSON

object ReadJsonRDDExample {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf()
      .setMaster("local[*]")
      .setAppName("ReadJsonRDDExample")
    val sc = new SparkContext(conf)

    val inputJsonFile = sc.textFile(READ_DATA_DIR + "people.json")

    val content = inputJsonFile.map(JSON.parseFull)
    println(content.collect.mkString("\t"))

    content.foreach(
      {
        case Some(map: Map[String, Any]) => println(map)
        case None => println("无效的Json")
        case _ => println("其他异常")
      }
    )

    sc.stop()
  }
}


package com.shockang.study.spark.sql.read

import com.shockang.study.spark._
import org.apache.spark.sql.SparkSession

/**
 * 读取 json 文件
 *
 * @author Shockang
 */
object ReadJsonDataFrameExample {

  def main(args: Array[String]): Unit = {

    // 使用 Spark 2.0 提供的 SparkSession API 来访问应用程序
    val spark = SparkSession.builder().master("local[*]").appName("ReadJsonDataFrameExample").getOrCreate()

    // 读取文本文件
    val inputJsonFile = spark.read.json(READ_DATA_DIR + "employees.json")

    printArray(inputJsonFile.collect())
    // 停止 spark，结束该任务
    spark.stop()
  }
}

MySQL

package com.shockang.study.spark.core.read

import com.shockang.study.spark.{MYSQL_JDBC_URL, MYSQL_PASS, MYSQL_USER}
import org.apache.spark.rdd.JdbcRDD
import org.apache.spark.{SparkConf, SparkContext}

import java.sql.DriverManager

object ReadMysqlRDDExample {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf()
      .setMaster("local[*]")
      .setAppName("ReadMysqlRDDExample")
    val sc = new SparkContext(conf)

    val inputMysql = new JdbcRDD(sc,
      () => {
        Class.forName("com.mysql.jdbc.Driver")
        DriverManager.getConnection(MYSQL_JDBC_URL, MYSQL_USER, MYSQL_PASS)
      },
      "SELECT * FROM person WHERE id >= ? and id <= ?;",
      1,
      3,
      1,
      r => (r.getInt(1), r.getString(2), r.getInt(3)))

    println("查询到的记录条目数：" + inputMysql.count)
    inputMysql.foreach(println)

    sc.stop()
  }
}


package com.shockang.study.spark.sql.read

import com.shockang.study.spark.{MYSQL_DB_TABLE, MYSQL_JDBC_URL, MYSQL_PASS, MYSQL_USER}
import org.apache.spark.sql.SparkSession

import java.util.Properties

/**
 *
 * @author Shockang
 */
object ReadMysqlDataFrameExample {
  def main(args: Array[String]): Unit = {
    // 使用 Spark 2.0 提供的 SparkSession API 来访问应用程序
    val spark = SparkSession.builder().master("local[*]").appName("ReadCsvDataFrameExample").getOrCreate()

    val jdbcDF = spark.read
      .format("jdbc")
      .option("url", MYSQL_JDBC_URL)
      .option("dbtable", MYSQL_DB_TABLE)
      .option("user", MYSQL_USER)
      .option("password", MYSQL_PASS)
      .load()
    jdbcDF.show()

    val connectionProperties = new Properties()
    connectionProperties.put("user", MYSQL_USER)
    connectionProperties.put("password", MYSQL_PASS)
    val jdbcDF2 = spark.read
      .jdbc(MYSQL_JDBC_URL, MYSQL_DB_TABLE, connectionProperties)
    jdbcDF2.show()

    connectionProperties.put("customSchema", "id DECIMAL(38, 0), name STRING")
    val jdbcDF3 = spark.read
      .jdbc(MYSQL_JDBC_URL, MYSQL_DB_TABLE, connectionProperties)
    jdbcDF3.show()
  }
}

Object 文件

package com.shockang.study.spark.core.read

import com.shockang.study.spark._
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}

/**
 * 读取 object 文件
 *
 * @author Shockang
 */
object ReadObjectRDDExample {

  case class Person(name: String, age: Int)

  def main(args: Array[String]): Unit = {

    // 初始化 SparkConf 对象，设置基本任务参数
    val conf: SparkConf = new SparkConf()
      // 设置提交任务的目标 Master 机器地址，local 为本地运行，[*]为自动分配任务线程数
      .setMaster("local[*]")
      // 设置任务名称
      .setAppName("ReadObjectRDDExample")

    // 实例化 SparkContext
    val sc: SparkContext = new SparkContext(conf)

    val filePath: String = READ_DATA_DIR + "people.object"
    val rdd: RDD[Person] = sc.objectFile[Person](filePath)

    printArray(rdd.collect)

    sc.stop()
  }
}

SequenceFile

package com.shockang.study.spark.core.read

import com.shockang.study.spark._
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}

/**
 * 读取 SequenceFile
 *
 * @author Shockang
 */
object ReadSequenceRDDExample {
  def main(args: Array[String]): Unit = {

    // 初始化 SparkConf 对象，设置基本任务参数
    val conf: SparkConf = new SparkConf()
      // 设置提交任务的目标 Master 机器地址，local 为本地运行，[*]为自动分配任务线程数
      .setMaster("local[*]")
      // 设置任务名称
      .setAppName("ReadSequenceRDDExample")
    // 实例化 SparkContext
    val sc: SparkContext = new SparkContext(conf)
    val path: String = READ_DATA_DIR + "people.sequence"

    // sequenceFile 应当使用 Hadoop 的 Writable 接口实现类，像 IntWritable 和 Text
    // Spark 也允许使用一些原生类型，比如， sequenceFile[Int, String] 会自动转换成 IntWritable 和 Text
    val rdd: RDD[(String, String)] = sc.sequenceFile[String, String](path)
    printArray(rdd.collect)
    sc.stop()
  }
}

TXT

package com.shockang.study.spark.core.read

import com.shockang.study.spark._
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}

/**
 * 读取 txt 文件
 *
 * @author Shockang
 */
object ReadTxtRDDExample {
  def main(args: Array[String]): Unit = {

    // 初始化 SparkConf 对象，设置基本任务参数
    val conf: SparkConf = new SparkConf()
      // 设置提交任务的目标 Master 机器地址，local 为本地运行，[*]为自动分配任务线程数
      .setMaster("local[*]")
      // 设置任务名称
      .setAppName("ReadTxtRDDExample")
    // 实例化 SparkContext
    val sc: SparkContext = new SparkContext(conf)
    sc.setLogLevel("ERROR")

    // 读取文本文件，支持目录，压缩文件和通配符
    val txtRDD: RDD[String] = sc.textFile(READ_DATA_DIR + "people.txt")
    printArray(txtRDD.collect)

    val dirRDD: RDD[String] = sc.textFile(READ_DATA_DIR)
    printArray(dirRDD.collect)

    // 默认支持 gzip 压缩
    val gzipRDD: RDD[String] = sc.textFile(READ_DATA_DIR + "people.gz")
    printArray(gzipRDD.collect)

    val wildcardsRDD: RDD[String] = sc.textFile(READ_DATA_DIR + "*.txt")
    printArray(wildcardsRDD.collect)

    // 支持自定义分区数
    val txtRDDWithMinPartitions: RDD[String] = sc.textFile(READ_DATA_DIR + "people.txt", 1)
    printArray(txtRDDWithMinPartitions.collect)

    // 读取目录下所有文本文件
    val wholeTxtRDD: RDD[(String, String)] = sc.wholeTextFiles(READ_DATA_DIR)
    // 结果日志输出，返回（文件名称，文件内容）对
    printArray(wholeTxtRDD.collect)

    // 读取目录下所有文本文件，同样支持自定义分区数
    val wholeTxtRDDWithMinPartitions: RDD[(String, String)] = sc.wholeTextFiles(READ_DATA_DIR, 1)
    // 结果日志输出，返回（文件名称，文件内容）对
    printArray(wholeTxtRDDWithMinPartitions.collect)

    // 停止sc，结束该任务
    sc.stop()
  }
}


package com.shockang.study.spark.sql.read

import com.shockang.study.spark.{READ_DATA_DIR, printArray}
import org.apache.spark.sql.SparkSession

/**
 * 读取 txt 文件
 *
 * @author Shockang
 */
object ReadTxtDataFrameExample {
  def main(args: Array[String]): Unit = {

    // 使用 Spark 2.0 提供的 SparkSession API 来访问应用程序
    val spark = SparkSession.builder().master("local[*]").appName("ReadTxtDataFrameExample").getOrCreate()

    // 读取 txt 文件
    val inputTextFile = spark.read.textFile(READ_DATA_DIR + "people.txt")

    // 结果日志输出
    printArray(inputTextFile.collect)

    // 读取目录下所有 txt 文本文件
    val allTextFile = spark.read.textFile(READ_DATA_DIR + "*.txt")

    // 结果日志输出
    printArray(allTextFile.collect)

    // 停止sc，结束该任务
    spark.stop()
  }
}

写

CSV

package com.shockang.study.spark.core.write

import com.shockang.study.spark.WRITE_DATA_DIR
import com.shockang.study.spark.util.Utils.writableLocalFsPath
import org.apache.spark.{SparkConf, SparkContext}

object WriteCsvRDDExample {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf()
      .setMaster("local[*]")
      .setAppName("WriteCsvRDDExample")
    val sc = new SparkContext(conf)

    val array = Array("Thomas", 18, "male", "65kg", "180cm")

    //转换成CSV格式保存
    val csvRDD = sc.parallelize(Array(array.mkString(",")), 1)
    val csvPath = WRITE_DATA_DIR + "WriteCsvRDDExample1"
    csvRDD.saveAsTextFile(writableLocalFsPath(csvPath))

    //转换成TSV格式保存
    val tsvRDD = sc.parallelize(Array(array.mkString("\t")), 1)
    val tsvPath = WRITE_DATA_DIR + "WriteCsvRDDExample2"
    tsvRDD.saveAsTextFile(writableLocalFsPath(tsvPath))

    sc.stop
  }
}


package com.shockang.study.spark.sql.write

import com.shockang.study.spark.WRITE_DATA_DIR
import com.shockang.study.spark.util.Utils.writableLocalFsPath
import org.apache.spark.sql.SparkSession

/**
 * 写入数据到 csv/tsv 文件
 *
 * @author Shockang
 */
object WriteCsvDataFrameExample {
  def main(args: Array[String]): Unit = {

    // 使用 Spark 2.0 提供的 SparkSession API 来访问应用程序
    val spark = SparkSession.builder().master("local[*]").appName("UsingSqlWriteTxtExample").getOrCreate()

    //转换成CSV格式保存
    val df = spark.createDataFrame(List(("one", 1), ("two", 2), ("three", 3)))
    val csvPath = WRITE_DATA_DIR + "WriteCsvDataFrameExample1"
    df.write.csv(writableLocalFsPath(csvPath))

    //转换成TSV格式保存
    val tsvPath = WRITE_DATA_DIR + "WriteCsvDataFrameExample2"
    df.write.option("delimiter", "\\t").csv(writableLocalFsPath(tsvPath))

    spark.stop
  }
}

Hadoop

package com.shockang.study.spark.core.write


import com.shockang.study.spark._
import org.apache.hadoop.io.{LongWritable, Text}
import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}

object WriteHadoopRDDExample {
  def main(args: Array[String]): Unit = {
    // 初始化 SparkConf 对象，设置基本任务参数
    val conf: SparkConf = new SparkConf()
      // 设置提交任务的目标 Master 机器地址，local 为本地运行，[*]为自动分配任务线程数
      .setMaster("local[*]")
      // 设置任务名称
      .setAppName("WriteHadoopRDDExample")
    // 实例化 SparkContext
    val sc: SparkContext = new SparkContext(conf)

    val rdd: RDD[(String, String)] = sc.parallelize(Seq(("Michael", "29"), ("Andy", "30"), ("Justin", "19")), 1).cache()

    // 使用 Hadoop 旧 API
    val oldPath: String = HDFS_WRITE_DIR + "WriteHadoopRDDExampleWithOldAPI"
    rdd.saveAsHadoopFile(oldPath, classOf[LongWritable], classOf[Text], classOf[org.apache.hadoop.mapred.TextOutputFormat[LongWritable, Text]])

    // 使用 Hadoop 新 API
    val newPath: String = HDFS_WRITE_DIR + "WriteHadoopRDDExampleWithNewAPI"
    rdd.saveAsNewAPIHadoopFile(newPath, classOf[LongWritable], classOf[Text], classOf[TextOutputFormat[LongWritable, Text]])

    sc.stop
  }
}

JSON

package com.shockang.study.spark.core.write

import com.shockang.study.spark.WRITE_DATA_DIR
import com.shockang.study.spark.util.Utils.writableLocalFsPath
import org.apache.spark.{SparkConf, SparkContext}

import scala.util.parsing.json.{JSONArray, JSONObject}

object WriteJsonRDDExample {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf()
      .setMaster("local[*]")
      .setAppName("WriteJsonRDDExample")
    val sc = new SparkContext(conf)

    val map1 = Map("name" -> "Thomas", "age" -> "20", "address" -> JSONArray(List("通信地址1", "通信地址2")))
    val map2 = Map("name" -> "Alice", "age" -> "18", "address" -> JSONArray(List("通信地址1", "通信地址2", "通信地址3")))

    val rddData = sc.parallelize(List(JSONObject(map1), JSONObject(map2)), 1)
    val tsvPath = WRITE_DATA_DIR + "WriteJsonRDDExample"
    rddData.saveAsTextFile(writableLocalFsPath(tsvPath))

    sc.stop()
  }
}


package com.shockang.study.spark.sql.write

import com.shockang.study.spark._
import com.shockang.study.spark.util.Utils.writableLocalFsPath
import org.apache.spark.sql.SparkSession

/**
 * 写入数据到 json 文件
 *
 * @author Shockang
 */
object WriteJsonDataFrameExample {

  def main(args: Array[String]): Unit = {

    // 使用 Spark 2.0 提供的 SparkSession API 来访问应用程序
    val spark = SparkSession.builder().master("local[*]").appName("UsingSqlWriteTxtExample").getOrCreate()

    //转换成CSV格式保存
    val df = spark.createDataFrame(List(("one", 1), ("two", 2), ("three", 3)))
    val csvPath = WRITE_DATA_DIR + "WriteCsvDataFrameExample1"
    df.write.csv(writableLocalFsPath(csvPath))
  }
}

MySQL

package com.shockang.study.spark.core.write

import com.shockang.study.spark.{MYSQL_JDBC_URL, MYSQL_PASS, MYSQL_USER}
import org.apache.spark.{SparkConf, SparkContext}

import java.sql.DriverManager

object WriteMysqlRDDExample {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf()
      .setMaster("local[*]")
      .setAppName("WriteMysqlRDDExample")
    val sc = new SparkContext(conf)

    Class.forName("com.mysql.jdbc.Driver")

    val rddData = sc.parallelize(List(("Alice", 30), ("Kotlin", 37)))
    rddData.foreachPartition((iter: Iterator[(String, Int)]) => {
      val conn = DriverManager.getConnection(MYSQL_JDBC_URL, MYSQL_USER, MYSQL_PASS)
      conn.setAutoCommit(false)
      val preparedStatement = conn.prepareStatement("INSERT INTO spark_examples.person (`name`, `age`) VALUES (?, ?);")
      iter.foreach(t => {
        preparedStatement.setString(1, t._1)
        preparedStatement.setInt(2, t._2)
        preparedStatement.addBatch()
      })
      preparedStatement.executeBatch()
      conn.commit()
      conn.close()
    })
    sc.stop()
  }
}


package com.shockang.study.spark.sql.write

import com.shockang.study.spark.{MYSQL_DB_TABLE, MYSQL_JDBC_URL, MYSQL_PASS, MYSQL_USER}
import org.apache.spark.sql.SparkSession

import java.util.Properties

/**
 *
 * @author Shockang
 */
object WriteMysqlDataFrameExample {
  def main(args: Array[String]): Unit = {
    // 使用 Spark 2.0 提供的 SparkSession API 来访问应用程序
    val spark = SparkSession.builder().master("local[*]").appName("ReadCsvDataFrameExample").getOrCreate()

    val df = spark.createDataFrame(List(
      ("Alice", "Female", "20"),
      ("Tom", "Male", "25"),
      ("Boris", "Male", "18"))).toDF("name", "sex", "age")

    // Saving data to a JDBC source
    df.write
      .format("jdbc")
      .option("url", MYSQL_JDBC_URL)
      .option("dbtable", MYSQL_DB_TABLE)
      .option("user", MYSQL_USER)
      .option("password", MYSQL_PASS)
      .save()

    val connectionProperties = new Properties()
    connectionProperties.put("user", MYSQL_USER)
    connectionProperties.put("password", MYSQL_PASS)

    df.write
      .jdbc(MYSQL_JDBC_URL, MYSQL_DB_TABLE, connectionProperties)

    df.write
      .option("createTableColumnTypes", "name CHAR(64), comments VARCHAR(1024)")
      .jdbc(MYSQL_JDBC_URL, MYSQL_DB_TABLE, connectionProperties)
  }
}

Object 文件

package com.shockang.study.spark.core.write

import com.shockang.study.spark._
import com.shockang.study.spark.core.read.ReadObjectRDDExample.Person
import com.shockang.study.spark.util.Utils.writableLocalFsPath
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}

/**
 *
 * 写入数据到 object 文件
 *
 * @author Shockang
 */
object WriteObjectRDDExample {
  def main(args: Array[String]): Unit = {

    // 初始化 SparkConf 对象，设置基本任务参数
    val conf: SparkConf = new SparkConf()
      // 设置提交任务的目标 Master 机器地址，local 为本地运行，[*]为自动分配任务线程数
      .setMaster("local[*]")
      // 设置任务名称
      .setAppName("WriteObjectRDDExample")
    // 实例化 SparkContext
    val sc: SparkContext = new SparkContext(conf)

    val rdd: RDD[Person] = sc.parallelize(Seq(Person("小明", 20), Person("Alice", 18)), 1)
    val filePath: String = WRITE_DATA_DIR + "WriteObjectRDDExample"
    rdd.saveAsObjectFile(writableLocalFsPath(filePath))

    sc.stop()
  }
}

SequenceFile

package com.shockang.study.spark.core.write

import com.shockang.study.spark._
import com.shockang.study.spark.util.Utils.writableLocalFsPath
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}

/**
 *
 * 写入数据到 SequenceFile
 *
 * @author Shockang
 */
object WriteSequenceRDDExample {
  def main(args: Array[String]): Unit = {

    // 初始化 SparkConf 对象，设置基本任务参数
    val conf: SparkConf = new SparkConf()
      // 设置提交任务的目标 Master 机器地址，local 为本地运行，[*]为自动分配任务线程数
      .setMaster("local[*]")
      // 设置任务名称
      .setAppName("WriteSequenceRDDExample")
    // 实例化 SparkContext
    val sc: SparkContext = new SparkContext(conf)
    val rdd: RDD[(String, String)] = sc.parallelize(Seq(("姓名", "小明"), ("年龄", "18")), 1)
    val path: String = WRITE_DATA_DIR + "WriteSequenceExample"
    rdd.saveAsSequenceFile(writableLocalFsPath(path))

    sc.stop()
  }
}

TXT

package com.shockang.study.spark.core.write

import com.shockang.study.spark._
import com.shockang.study.spark.util.Utils.writableLocalFsPath
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}

/**
 * 写入数据到 txt 文件
 *
 * @author Shockang
 */
object WriteTxtRDDExample {
  def main(args: Array[String]): Unit = {

    // 初始化 SparkConf 对象，设置基本任务参数
    val conf: SparkConf = new SparkConf()
      // 设置提交任务的目标 Master 机器地址，local 为本地运行，[*]为自动分配任务线程数
      .setMaster("local[*]")
      // 设置任务名称
      .setAppName("WriteTxtRDDExample")
    // 实例化 SparkContext
    val sc: SparkContext = new SparkContext(conf)

    val rdd: RDD[(String, Int)] = sc.parallelize(Array(("one", 1), ("two", 2), ("three", 3)), 1)
    val filePath: String = WRITE_DATA_DIR + "WriteTxtRDDExample"
    rdd.saveAsTextFile(writableLocalFsPath(filePath))

    sc.stop
  }
}


package com.shockang.study.spark.sql.write

import com.shockang.study.spark.WRITE_DATA_DIR
import com.shockang.study.spark.util.Utils.writableLocalFsPath
import org.apache.spark.sql.SparkSession

/**
 * 写入数据到 txt 文件
 *
 * @author Shockang
 */
object WriteTxtDataFrameExample {

  case class Person(name: String, sex: String, age: Int)

  def main(args: Array[String]): Unit = {

    // 使用 Spark 2.0 提供的 SparkSession API 来访问应用程序
    val spark = SparkSession.builder().master("local[*]").appName("UsingSqlWriteTxtExample").getOrCreate()

    // 注意隐式导入
    import spark.implicits._

    // 由于 txt 只支持 String 类型的数据，故需要经过转换
    val df = spark.createDataFrame(List(("one", 1), ("two", 2), ("three", 3))).map(_.mkString("(", ", ", ")"))

    val filePath = WRITE_DATA_DIR + "WriteTxtDataFrameExample"

    df.write.text(writableLocalFsPath(filePath))

    spark.stop
  }
}

Parquet

package com.shockang.study.spark.sql.read

import com.shockang.study.spark._
import org.apache.spark.sql.SparkSession

/**
 *
 * @author Shockang
 */
object ParquetExample {
  def main(args: Array[String]): Unit = {
    // 使用 Spark 2.0 提供的 SparkSession API 来访问应用程序
    val spark = SparkSession.builder().master("local[*]").appName("ParquetExample").getOrCreate()

    import spark.implicits._

    val peopleDF = spark.read.json(READ_DATA_DIR + "people.json")

    peopleDF.write.parquet(WRITE_DATA_DIR + "people.parquet")

    val parquetFileDF = spark.read.parquet(WRITE_DATA_DIR + "people.parquet")

    parquetFileDF.createOrReplaceTempView("parquetFile")
    val namesDF = spark.sql("SELECT name FROM parquetFile WHERE age BETWEEN 10 AND 20")
    namesDF.map(attributes => "Name: " + attributes(0)).show()
  }
}
Shockang
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于spark的大数据论文资料
12-17
本资料是集合20篇知网被引最高的基于spark的大数据论文，包括大数据Spark技术研究_刘峰波、大数据下基于Spark的电商实时推荐系统的设计与实现_岑凯伦、基于Spark的Apriori算法的改进_牛海玲、基于Spark的大数据混合计算模型_胡俊、基于Spark的大数据挖掘技术的研究与实现_李文栋、基于Spark的机器学习平台设计与实现_唐振坤、基于Spark的机器学习应用框架研究与实现_孙科、基于Spark的若干数据挖掘技术研究_宁永恒、基于Spark平台推荐系统研究_杨志伟等高质量的论文。
【Spark床头书系列】Spark SparkSession由来方法示例源码分析
wang2leee的博客
09-20 538
它将SQLContext和HiveContext的功能合并到一个统一的接口中，并提供了更多的功能和便利性。它还提供了更多的集成选项和功能扩展，例如对结构化流处理的支持。总之，SparkSession是Apache Spark中用于与Spark集群交互的主要入口点，提供了统一的编程接口和丰富的功能，使得数据处理更加方便和高效。SparkSession的目标是为用户提供一个统一且一致的编程接口，无论是进行交互式数据探索、批处理作业还是流式处理任务，都能使用相同的代码模型和API。
解决java+Spark进行数据去重的具体操作步骤
WBKJ_Noah的博客
07-08 535
数据去重是处理大数据的一个常见任务，可以帮助我们快速识别和删除重复的数据行。然后，我们可以使用SparkSession来加载我们的数据。在上述代码中，我们调用了dropDuplicates()方法来对数据进行去重操作，并将结果保存在一个新的Dataset对象中。一旦我们加载了数据，我们就可以执行数据去重操作了。在上面的代码中，我们调用了write().csv()方法来将去重后的数据保存为CSV格式，并指定了输出路径。现在，你可以将数据去重的代码封装在一个可执行的Java程序中，并运行它来实现数据去重。
构建sparkSession工具类
qq_65303368的博客
03-08 484
【代码】构建sparkSession工具类。
sparksesion java_SparkSession：新的切入点
weixin_33637634的博客
02-25 650
在, SQLContext和HiveContext之间关系的问题。当人们想使用DataFrame API的时候把HiveContext当做切入点的确有点奇怪。在本文是使用Scala编写的，但是Python和Java中同样可用。Creating a SparkSessionSparkSession可以通过建造者模式创建。如果SparkContext存在，那么SparkSession将会重用它；但是如...
基于Scala的Spark大数据处理代码设计源码
最新发布
04-08
Spark大数据处理代码：基于Scala开发，包含131个文件，包括127个Scala源文件、1个LICENSE文件、1个Markdown文档、1个XML配置文件和1个Properties配置文件。该项目是由刘彪提供的Spark大数据处理代码，可用于进行数据...
Spark性能优化：开发调优篇
02-01
Spark性能优化的第一步，...通常来说，我们在开发一个Spark作业时，首先是基于某个数据源（比如Hive表或HDFS文件）创建一个初始的RDD；接着对这个RDD执行某个算子操作，然后得到下一个RDD；以此类推，循环往复，直到计
用Spark进行大数据处理之机器学习篇
02-25
在本篇文章，作者将讨论机器学习概念以及如何使用SparkMLlib来进行预测分析。后面将会使用一个例子展示SparkMLlib在机器学习领域的强悍。Spark机器学习API包含两个package：spark.mllib和spark.ml。spark.mllib包含...
sparksesion java_【sparkSQL】SparkSession的认识
weixin_32903229的博客
02-25 722
在Spark1.6中我们使用的叫Hive on spark，主要是依赖hive生成spark程序，有两个核心组件SQLcontext和HiveContext。这是Spark 1.x 版本的语法//set up the spark configuration and create contextsval sparkConf = new SparkConf().setAppName("SparkSes...
论文推荐 Spark
孤影渐苍茫的博客
02-26 1759
推荐一些关于Spark的论文
Spark原理
12-24 661
参考文献： Spark原理总结 Github: Apache spark project Spark修炼之道（进阶篇）spark修炼之道（高级篇） Resilient Distributed Datasets: A Fault-Tolerant Abstraction for In-Memory Cluster Computing Spark简介  Spark是UC Berkeley ...
第十课 使用java开发spark 实战
a11a2233445566的专栏
10-11 959
课程内容  使用ide开发spark 实战 使用ide 开发spark的Local和Cluster  一： 配置开发环境 1. 要在本地安装好java和scala。 由于spark1.6需要scala 2.10.X版本的。推荐 2.10.4，java版本最好是1.8。所以提前我们要需要安装好java和scala 并在环境变量中配置好。 2. 打开ide 新建scala projec
Spark的java开发环境实战
rishengcsdn的专栏
09-11 8434
看网上文档要用Spark开发搭建环境是挺麻烦的，需要多台机器安装Hadoop，还要建立和修改许多配置文件，有没有简单一点的方法呢？ 作者研究了一下，发现了一种非常简便的方法，能让小盆友们快速上手Spark又避免复杂安装命令。 研究了Spark的支持方面，我发现Spark2.2和mongodb3.4这两个家伙已经宣布了互相支持。这下子狼狈为奸，一脚踢开复杂难用的Hadoop了。
Spark使用SparkSession读写数据库
qq_36470898的博客
04-13 4555
一、SparkSession与SparkContext 首先介绍一下sparkC sss
SparkSeesion读写操作数据库
onway_goahead的博客
07-18 782
object JDBCDemo { def main(args: Array[String]): Unit = { //获取spark的连接 val session = SparkSession.builder() .master("local") .appName(JDBCDemo.getClass.getSimpleName) .getO...
大数据开发-spark+java
qq_27886773的博客
09-19 656
1.使用spark-submit的方式提交java任务 例如spark-submit --class aa.bb --master yarn --deploy-mode client --queue cc XXX.jar 。 指定queue是在spark-submit里面指定，在java代码里面通过spark.conf().set("queue", "cc") 的方式指定没有用。 在 y...
java spark 保存_Spark基础教程——文件读写操作
weixin_42311672的博客
02-25 639
Spark支持多种文件的读写操作，例如普通文本文件、JSON、CSV、SequenceFile等，而且Spark会根据文件后缀自动选择对应的处理方式。下面是Spark支持的常见的文本格式：格式名称结构化备注文本文件否普通文本，每行一条记录JSON是常见的基于文本的格式，半结构化数据CSV是常见的基于文本的格式，通常在Excel中使用SequenceFile是Hadoop文件格式，用于键值对数据Pr...
Spark 离线开发框架设计与实现
m0_65038841的博客
05-20 304
一、背景 随着 Spark 以及其社区的不断发展，Spark 本身技术也在不断成熟，Spark 在技术架构和性能上的优势越来越明显，目前大多数公司在大数据处理中都倾向使用 Spark。Spark 支持多种语言的开发，如 Scala、Java、Sql、Python 等。 Spark SQL 使用标准的数据连接，与 Hive 兼容，易与其它语言 API 整合，表达清晰、简单易上手、学习成本低，是开发者开发简单数据处理的首选语言，但对于复杂的数据处理、数据分析的开发，使用 SQL 开发显得力不从心，维护成本也
使用java开发spark 实战
a11a2233445566的专栏
01-18 7482
一：环境搭建 安装jdk 和maven。 1. 安装jdk并配置环境变量 系统变量→新建 JAVA_HOME 变量 。 变量值填写jdk的安装目录（本人是 E:\Java\jdk1.7.0) 系统变量→寻找 Path 变量→编辑 在变量值最后输入 %JAVA_HOME%\bin;%JAVA_HOME%\jre\bin;（注意原来Path的变量值末尾有没有;号，如果没有，先输入；
spark数据处理代码
05-27
下面是使用Spark进行数据处理的代码示例，包括数据导入、数据清洗和数据转换： ```python # 导入Spark相关库 from pyspark.sql import SparkSession from pyspark.sql.functions import * # 创建SparkSession ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值