1.说明
* 1.Rdd文件读取和保存 可以从两个角度来区分
* 文件格式 : text、json、csv、sequence文件、Object序列化文件
* 文件系统 : 本地文件系统、hdfs、hbase、各类型数据库
2.Spark中怎样读取&保存text文件？
1.读取
* 1.SparkContext.textFile
* 语法 :
* def textFile(path: String,minPartitions: Int = defaultMinPartitions)
* : RDD[String]
* 功能 :
* 从hdfs、本地文件系统(任何节点可用),或者任何文件系统中读取数据
* 并返回 Rdd[String]对象(文本文件的每一行都会成为Rdd的一个元素)
* 参数 :
* path : 文件系统路径,可用是hdfs的路径(多路径时用,分割)
* minPartitions : Rdd的最小分区数
* 返回值 :
* 返回一个Rdd,文本文件的每一行都会成为Rdd的一个元素
* note :
* 文本文件的编码必须是UTF-8
*
*2.SparkContext.wholeTextFiles
* 语法 :
* def wholeTextFiles(path: String,minPartitions: Int = defaultMinPartitions)
* : RDD[(String, String)]
* 功能 :
* 从hdfs、本地文件系统(任何节点可用),或者任何文件系统中读取数据,每个文件都会作为单个记录读取
* 并返回 RDD[(String, String)]对象(key:文件路径名称,value:文件内容)
* 参数 :
* path : 文件系统路径,可用是hdfs的路径(多路径时,用,分割)
* minPartitions : Rdd的最小分区数
* 返回值 :
* 返回一个Rdd,文本文件的每一行都会成为Rdd的一个元素
2.保存
* 1.rdd.saveAsTextFile
* 语法 :
* def saveAsTextFile(path: String): Unit = withScope
* def saveAsTextFile(path: String, codec: Class[_ <: CompressionCodec]): Unit
* 功能 :
* 将rdd保存为指定目录下的text
* 参数 :
* path : 文件系统路径,可用是hdfs的路径
* codec : 压缩算法实现类
3.示例
object textTest extends App {
val sparkconf: SparkConf = new SparkConf().setMaster("local").setAppName("distinctTest")
val sc: SparkContext = new SparkContext(sparkconf)
//1.读取指定路径下的text文件,返回rdd,每一行为rdd的一个元素
private val rdd1: RDD[String] = sc.textFile("Spark_319/src/data/input2")
//2.读取指定路径下的text文件,返回rdd,每个文件作为rdd的一个元素(key:文件路径,value:文件内容)
private val rdd2: RDD[(String, String)] = sc.wholeTextFiles("Spark_319/src/data/input2")
rdd1.collect().foreach(println(_))
println("***********************")
rdd2.collect().foreach(println(_))
//3.保存rdd到指定目录
rdd1.saveAsTextFile("Spark_319/src/data/01")
rdd2.saveAsTextFile("Spark_319/src/data/02")
sc.stop()
}
3.Spark中怎样读取&保存 sequence文件？
1.什么是 sequence文件？
SequenceFile文件是Hadoop用来存储 二进制形式的key-value对 而设计的一种平面文件
2.读取
* 1.读取
* def sequenceFile[K, V]
* (path: String, minPartitions: Int = defaultMinPartitions)
* (implicit km: ClassTag[K], vm: ClassTag[V],
* kcf: () => WritableConverter[K], vcf: () => WritableConverter[V]): RDD[(K, V)]
*
* def sequenceFile[K, V](
* path: String,
* keyClass: Class[K],
* valueClass: Class[V]): RDD[(K, V)]
*
* note : 有两种实现方式
* 1.参数中 不需要指定key,value类型,会根据变量的泛型 做隐式转换
* 2.参数中 需要手动指定key,value类型
3.保存
* def saveAsSequenceFile(
* path: String,
* codec: Option[Class[_ <: CompressionCodec]] = None): Unit
*
* note :
* 将Rdd作为Hadoop SequenceFile输出
* 会根据Rdd元素的key和value自动推断出Writable类型
4.示例
object sequenceTest extends App {
val sparkconf: SparkConf = new SparkConf().setMaster("local").setAppName("distinctTest")
val sc: SparkContext = new SparkContext(sparkconf)
private val rdd1 = sc.makeRDD(List((1, "张三"), (2, "张四")))
//1.保存rdd到指定目录
rdd1.saveAsSequenceFile("Spark_319/src/output/01")
//2.读取到指定路径下 sequence文件
//根据变量泛型确定key-value类型
private val rdd2: RDD[(Int, String)] = sc.sequenceFile("Spark_319/src/output/01")
//根据指定参数来确定key-value类型
private val rdd3: RDD[(IntWritable, Text)] = sc.sequenceFile("Spark_319/src/output/01", classOf[IntWritable], classOf[Text])
private val rdd4: RDD[(String, String)] = rdd2.map(
tp => (tp._1.toString, tp._2.toString)
)
rdd4.collect().foreach(println(_))
rdd2.collect().foreach(println(_))
sc.stop()
}
4.Spark中怎样读取(保存) object对象文件？
1.什么是 object对象文件？
object对象文件 是将对象序列化后的文本,采用java的序列化机制
2.读取
* def saveAsObjectFile(path: String): Unit
*
* def saveAsSequenceFile(
* path: String,
* codec: Option[Class[_ <: CompressionCodec]] = None): Unit
3.保存
* def objectFile[T: ClassTag](
* path: String,
* minPartitions: Int = defaultMinPartitions): RDD[T]
4.示例
object objectTest extends App {
val sparkconf: SparkConf = new SparkConf().setMaster("local").setAppName("distinctTest")
val sc: SparkContext = new SparkContext(sparkconf)
private val rdd1: RDD[(Int, String)] = sc.makeRDD(List((1, "张三"), (2, "张四")))
//1.保存rdd到指定目录
rdd1.saveAsObjectFile("Spark_319/src/output/02")
//2.读取 ObjectFile文件
private val rdd2: RDD[(Int, String)] = sc.objectFile("Spark_319/src/output/01")
rdd2.collect().foreach(println(_))
sc.stop()
}
5.Spark中怎样读取(保存) json文件？
1.说明
* 1.说明
* 将json按文本文件读取,在用Json解析器(Jackson、FirstJson)对Rdd中的值进行映射操作
*
* 2.note
* Json解析器需要类的反射,对象中必须要声明 构造器和属性的get、set方法
2.示例
object jsonTest extends App {
val sparkconf: SparkConf = new SparkConf().setMaster("local").setAppName("distinctTest")
val sc: SparkContext = new SparkContext(sparkconf)
//创建对象
private val p1 = new Person(1, "北京")
private val p2 = new Person(2, "上海")
private val p3 = new Person(3, "广州")
private val mapper = new ObjectMapper()
private val rdd1: RDD[Person] = sc.makeRDD(List(p1, p2, p3))
//将object转为json字符串
private val rdd2: RDD[String] = rdd1.map(mapper.writeValueAsString(_))
//rdd2.saveAsTextFile("Spark_319/src/output/02")
private val rdd3: RDD[String] = sc.textFile("Spark_319/src/output/02")
//将json文本转为哦object
private val rdd4: RDD[Person] = rdd3.map(
e => {
var objectMapper = new ObjectMapper()
objectMapper.readValue(e, classOf[Person])
}
)
rdd4.collect().foreach(println(_))
sc.stop()
}
case class Person() {
@BeanProperty var id: Int = _
@BeanProperty var address: String = _
def this(id: Int, address: String) {
this()
this.id = id
this.address = address
}
override def toString: String = {
s"Person : ${this.id} ${this.address}"
}
}
6.Spark中怎样读取(保存) csv文件？
浙公网安备 33010602011771号